X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=servers%2Fslapd%2Fconnection.c;h=504fe2cbfe0c13a82f0ef354426eded7eeaadd23;hb=008bbf56dbbe472cc0e95fb15e78c55e7e97e4c4;hp=319b20396e6ed234a4b76cc202f05bd73bd0a7ca;hpb=669b8f4047c03d4583a44ed8287d0d5920d15373;p=openldap

diff --git a/servers/slapd/connection.c b/servers/slapd/connection.c
index 319b20396e..504fe2cbfe 100644
--- a/servers/slapd/connection.c
+++ b/servers/slapd/connection.c
@@ -30,6 +30,18 @@ static unsigned long conn_nextid = 0;
 #define SLAP_C_BINDING			0x03	/* binding */
 #define SLAP_C_CLOSING			0x04	/* closing */
 
+char* connection_state2str( int state ) {
+	switch( state ) {
+	case SLAP_C_INVALID:	return "!";		
+	case SLAP_C_INACTIVE:	return "|";		
+	case SLAP_C_ACTIVE:		return "";			
+	case SLAP_C_BINDING:	return "B";
+	case SLAP_C_CLOSING:	return "C";			
+	}
+
+	return "?";
+}
+
 static Connection* connection_get( ber_socket_t s );
 
 static int connection_input( Connection *c );
@@ -37,6 +49,8 @@ static void connection_close( Connection *c );
 
 static int connection_op_activate( Connection *conn, Operation *op );
 static int connection_resched( Connection *conn );
+static void connection_abandon( Connection *conn );
+static void connection_destroy( Connection *c );
 
 struct co_arg {
 	Connection	*co_conn;
@@ -137,6 +151,35 @@ int connections_shutdown(void)
 	return 0;
 }
 
+/*
+ * Timeout idle connections.
+ */
+int connections_timeout_idle(time_t now)
+{
+	int i = 0;
+	int connindex;
+	Connection* c;
+
+	ldap_pvt_thread_mutex_lock( &connections_mutex );
+
+ 	for( c = connection_first( &connindex );
+		c != NULL;
+		c = connection_next( c, &connindex ) )
+	{
+		if( difftime( c->c_activitytime+global_idletimeout, now) < 0 ) {
+			/* close it */
+			connection_closing( c );
+			connection_close( c );
+			i++;
+		}
+	}
+	connection_done( c );
+
+	ldap_pvt_thread_mutex_unlock( &connections_mutex );
+
+	return i;
+}
+
 static Connection* connection_get( ber_socket_t s )
 {
 	/* connections_mutex should be locked by caller */
@@ -209,6 +252,8 @@ static Connection* connection_get( ber_socket_t s )
 			"connection_get(%d): got connid=%ld\n",
 			s, c->c_connid, 0 );
 
+		c->c_n_get++;
+
 		assert( c->c_struct_state == SLAP_C_USED );
 		assert( c->c_conn_state != SLAP_C_INVALID );
 		assert( ber_pvt_sb_in_use( c->c_sb ) );
@@ -226,13 +271,25 @@ static void connection_return( Connection *c )
 
 long connection_init(
 	ber_socket_t s,
-	const char* name,
-	const char* addr)
+	const char* url,
+	const char* dnsname,
+	const char* peername,
+	const char* sockname,
+	int use_tls )
 {
 	unsigned long id;
 	Connection *c;
+
 	assert( connections != NULL );
 
+	assert( dnsname != NULL );
+	assert( peername != NULL );
+	assert( sockname != NULL );
+
+#ifndef HAVE_TLS
+	assert( !use_tls );
+#endif
+
 	if( s == AC_SOCKET_INVALID ) {
         Debug( LDAP_DEBUG_ANY,
 			"connection_init(%ld): invalid.\n",
@@ -291,10 +348,16 @@ long connection_init(
     if( c->c_struct_state == SLAP_C_UNINITIALIZED ) {
         c->c_dn = NULL;
         c->c_cdn = NULL;
-        c->c_client_name = NULL;
-        c->c_client_addr = NULL;
+
+		c->c_listener_url = NULL;
+		c->c_peer_domain = NULL;
+        c->c_peer_name = NULL;
+        c->c_sock_name = NULL;
+
         c->c_ops = NULL;
         c->c_pending_ops = NULL;
+		c->c_authmech = NULL;
+		c->c_authstate = NULL;
 
         c->c_sb = ber_sockbuf_alloc( );
 
@@ -311,20 +374,28 @@ long connection_init(
     assert( c->c_struct_state == SLAP_C_UNUSED );
     assert(	c->c_dn == NULL );
     assert(	c->c_cdn == NULL );
-    assert( c->c_client_name == NULL );
-    assert( c->c_client_addr == NULL );
+    assert( c->c_listener_url == NULL );
+    assert( c->c_peer_domain == NULL );
+    assert( c->c_peer_name == NULL );
+    assert( c->c_sock_name == NULL );
     assert( c->c_ops == NULL );
     assert( c->c_pending_ops == NULL );
+	assert( c->c_authmech == NULL );
+	assert( c->c_authstate == NULL );
 
-    c->c_client_name = ch_strdup( name == NULL ? "" : name );
-    c->c_client_addr = ch_strdup( addr );
+	c->c_listener_url = ch_strdup( url  );
+	c->c_peer_domain = ch_strdup( dnsname  );
+    c->c_peer_name = ch_strdup( peername  );
+    c->c_sock_name = ch_strdup( sockname );
 
     c->c_n_ops_received = 0;
-#ifdef LDAP_COUNTERS
     c->c_n_ops_executing = 0;
     c->c_n_ops_pending = 0;
     c->c_n_ops_completed = 0;
-#endif
+
+	c->c_n_get = 0;
+	c->c_n_read = 0;
+	c->c_n_write = 0;
 
     c->c_activitytime = c->c_starttime = slap_get_time();
 
@@ -333,8 +404,8 @@ long connection_init(
 
     if( ber_pvt_sb_set_nonblock( c->c_sb, 1 ) < 0 ) {
         Debug( LDAP_DEBUG_ANY,
-            "connection_init(%d, %s, %s): set nonblocking failed\n",
-            s, c->c_client_name, c->c_client_addr);
+            "connection_init(%d, %s): set nonblocking failed\n",
+            s, c->c_peer_name,0 );
     }
 
     id = c->c_connid = conn_nextid++;
@@ -342,9 +413,18 @@ long connection_init(
     c->c_conn_state = SLAP_C_INACTIVE;
     c->c_struct_state = SLAP_C_USED;
 
+#ifdef HAVE_TLS
+    if ( use_tls ) {
+	    c->c_is_tls = 1;
+	    c->c_needs_tls_accept = 1;
+    }
+#endif
+
     ldap_pvt_thread_mutex_unlock( &c->c_mutex );
     ldap_pvt_thread_mutex_unlock( &connections_mutex );
 
+    backend_connection_init(c);
+
     return id;
 }
 
@@ -359,10 +439,10 @@ connection_destroy( Connection *c )
     assert( c->c_conn_state != SLAP_C_INVALID );
     assert( c->c_ops == NULL );
 
-#ifdef LDAP_COMPAT30
-    c->c_version = 0;
-#endif
+    backend_connection_destroy(c);
+
     c->c_protocol = 0;
+    c->c_connid = -1;
 
     c->c_activitytime = c->c_starttime = 0;
 
@@ -374,13 +454,29 @@ connection_destroy( Connection *c )
 		free(c->c_cdn);
 		c->c_cdn = NULL;
 	}
-	if(c->c_client_name != NULL) {
-		free(c->c_client_name);
-		c->c_client_name = NULL;
+	if(c->c_listener_url != NULL) {
+		free(c->c_listener_url);
+		c->c_listener_url = NULL;
+	}
+	if(c->c_peer_domain != NULL) {
+		free(c->c_peer_domain);
+		c->c_peer_domain = NULL;
+	}
+	if(c->c_peer_name != NULL) {
+		free(c->c_peer_name);
+		c->c_peer_name = NULL;
+	}
+	if(c->c_sock_name != NULL) {
+		free(c->c_sock_name);
+		c->c_sock_name = NULL;
+	}
+	if(c->c_authmech != NULL ) {
+		free(c->c_authmech);
+		c->c_authmech = NULL;
 	}
-	if(c->c_client_addr != NULL) {
-		free(c->c_client_addr);
-		c->c_client_addr = NULL;
+	if(c->c_authstate != NULL ) {
+		free(c->c_authstate);
+		c->c_authstate = NULL;
 	}
 
 	if ( ber_pvt_sb_in_use(c->c_sb) ) {
@@ -415,6 +511,27 @@ int connection_state_closing( Connection *c )
 	return state == SLAP_C_CLOSING;
 }
 
+static void connection_abandon( Connection *c )
+{
+	/* c_mutex must be locked by caller */
+
+	Operation *o;
+
+	for( o = c->c_ops; o != NULL; o = o->o_next ) {
+		ldap_pvt_thread_mutex_lock( &o->o_abandonmutex );
+		o->o_abandon = 1;
+		ldap_pvt_thread_mutex_unlock( &o->o_abandonmutex );
+	}
+
+	/* remove pending operations */
+	for( o = slap_op_pop( &c->c_pending_ops );
+		o != NULL;
+		o = slap_op_pop( &c->c_pending_ops ) )
+	{
+		slap_op_free( o );
+	}
+}
+
 void connection_closing( Connection *c )
 {
 	assert( connections != NULL );
@@ -425,7 +542,6 @@ void connection_closing( Connection *c )
 	/* c_mutex must be locked by caller */
 
 	if( c->c_conn_state != SLAP_C_CLOSING ) {
-		Operation *o;
 
 		Debug( LDAP_DEBUG_TRACE,
 			"connection_closing: readying conn=%ld sd=%d for close.\n",
@@ -440,19 +556,7 @@ void connection_closing( Connection *c )
 		/* shutdown I/O -- not yet implemented */
 
 		/* abandon active operations */
-		for( o = c->c_ops; o != NULL; o = o->o_next ) {
-			ldap_pvt_thread_mutex_lock( &o->o_abandonmutex );
-			o->o_abandon = 1;
-			ldap_pvt_thread_mutex_unlock( &o->o_abandonmutex );
-		}
-
-		/* remove pending operations */
-		for( o = slap_op_pop( &c->c_pending_ops );
-			o != NULL;
-			o = slap_op_pop( &c->c_pending_ops ) )
-		{
-			slap_op_free( o );
-		}
+		connection_abandon( c );
 
 		/* wake write blocked operations */
 		slapd_clr_write( ber_pvt_sb_get_desc(c->c_sb), 1 );
@@ -568,79 +672,76 @@ void connection_done( Connection *c )
 static void *
 connection_operation( void *arg_v )
 {
+	int rc;
 	struct co_arg	*arg = arg_v;
 	ber_tag_t tag = arg->co_op->o_tag;
 	Connection *conn = arg->co_conn;
 
-#ifdef LDAP_COUNTERS
 	ldap_pvt_thread_mutex_lock( &num_ops_mutex );
 	num_ops_initiated++;
 	ldap_pvt_thread_mutex_unlock( &num_ops_mutex );
-#endif
 
 	switch ( tag ) {
 	case LDAP_REQ_BIND:
-		do_bind( conn, arg->co_op );
+		rc = do_bind( conn, arg->co_op );
 		break;
 
-#ifdef LDAP_COMPAT30
-	case LDAP_REQ_UNBIND_30:
-#endif
 	case LDAP_REQ_UNBIND:
-		do_unbind( conn, arg->co_op );
+		rc = do_unbind( conn, arg->co_op );
 		break;
 
 	case LDAP_REQ_ADD:
-		do_add( conn, arg->co_op );
+		rc = do_add( conn, arg->co_op );
 		break;
 
-#ifdef LDAP_COMPAT30
-	case LDAP_REQ_DELETE_30:
-#endif
 	case LDAP_REQ_DELETE:
-		do_delete( conn, arg->co_op );
+		rc = do_delete( conn, arg->co_op );
 		break;
 
 	case LDAP_REQ_MODRDN:
-		do_modrdn( conn, arg->co_op );
+		rc = do_modrdn( conn, arg->co_op );
 		break;
 
 	case LDAP_REQ_MODIFY:
-		do_modify( conn, arg->co_op );
+		rc = do_modify( conn, arg->co_op );
 		break;
 
 	case LDAP_REQ_COMPARE:
-		do_compare( conn, arg->co_op );
+		rc = do_compare( conn, arg->co_op );
 		break;
 
 	case LDAP_REQ_SEARCH:
-		do_search( conn, arg->co_op );
+		rc = do_search( conn, arg->co_op );
 		break;
 
-#ifdef LDAP_COMPAT30
-	case LDAP_REQ_ABANDON_30:
-#endif
 	case LDAP_REQ_ABANDON:
-		do_abandon( conn, arg->co_op );
+		rc = do_abandon( conn, arg->co_op );
+		break;
+
+	case LDAP_REQ_EXTENDED:
+		rc = do_extended( conn, arg->co_op );
 		break;
 
 	default:
-		Debug( LDAP_DEBUG_ANY, "unknown request 0x%lx\n",
-		    arg->co_op->o_tag, 0, 0 );
+		Debug( LDAP_DEBUG_ANY, "unknown LDAP request 0x%lx\n",
+		    tag, 0, 0 );
+		arg->co_op->o_tag = LBER_ERROR;
+		send_ldap_disconnect( conn, arg->co_op,
+			LDAP_PROTOCOL_ERROR, "unknown LDAP request" );
+		rc = -1;
 		break;
 	}
 
-#ifdef LDAP_COUNTERS
+	if( rc == -1 ) tag = LBER_ERROR;
+
 	ldap_pvt_thread_mutex_lock( &num_ops_mutex );
 	num_ops_completed++;
 	ldap_pvt_thread_mutex_unlock( &num_ops_mutex );
-#endif
 
 	ldap_pvt_thread_mutex_lock( &conn->c_mutex );
 
-#ifdef LDAP_COUNTERS
+	conn->c_n_ops_executing--;
 	conn->c_n_ops_completed++;
-#endif
 
 	slap_op_remove( &conn->c_ops, arg->co_op );
 	slap_op_free( arg->co_op );
@@ -650,9 +751,7 @@ connection_operation( void *arg_v )
 	arg = NULL;
 
 	switch( tag ) {
-#ifdef LDAP_COMPAT30
-	case LDAP_REQ_UNBIND_30:
-#endif
+	case LBER_ERROR:
 	case LDAP_REQ_UNBIND:
 		/* c_mutex is locked */
 		connection_closing( conn );
@@ -662,6 +761,7 @@ connection_operation( void *arg_v )
 		if( conn->c_conn_state == SLAP_C_BINDING) {
 			conn->c_conn_state = SLAP_C_ACTIVE;
 		}
+		conn->c_bind_in_progress = ( rc == LDAP_SASL_BIND_IN_PROGRESS );
 	}
 
 	ldap_pvt_thread_mutex_lock( &active_threads_mutex );
@@ -700,6 +800,8 @@ int connection_read(ber_socket_t s)
 		return -1;
 	}
 
+	c->c_n_read++;
+
 	if( c->c_conn_state == SLAP_C_CLOSING ) {
 		Debug( LDAP_DEBUG_TRACE,
 			"connection_read(%d): closing, ignoring input for id=%ld\n",
@@ -714,6 +816,27 @@ int connection_read(ber_socket_t s)
 		"connection_read(%d): checking for input on id=%ld\n",
 		s, c->c_connid, 0 );
 
+#ifdef HAVE_TLS
+	if ( c->c_is_tls && c->c_needs_tls_accept ) {
+		rc = ldap_pvt_tls_accept( c->c_sb, NULL );
+		if ( rc < 0 ) {
+			Debug( LDAP_DEBUG_TRACE,
+			       "connection_read(%d): TLS accept error error=%d id=%ld, closing.\n",
+			       s, rc, c->c_connid );
+
+			c->c_needs_tls_accept = 0;
+			/* connections_mutex and c_mutex are locked */
+			connection_closing( c );
+			connection_close( c );
+		} else if ( rc == 0 ) {
+			c->c_needs_tls_accept = 0;
+		}
+		connection_return( c );
+		ldap_pvt_thread_mutex_unlock( &connections_mutex );
+		return 0;
+	}
+#endif
+
 #define CONNECTION_INPUT_LOOP 1
 
 #ifdef DATA_READY_LOOP
@@ -722,6 +845,7 @@ int connection_read(ber_socket_t s)
 	while(!rc)
 #endif
 	{
+		/* How do we do this without getting into a busy loop ? */
 		rc = connection_input( c );
 	}
 
@@ -735,6 +859,10 @@ int connection_read(ber_socket_t s)
 		connection_close( c );
 	}
 
+	if ( ber_pvt_sb_needs_read( c->c_sb ) )
+		slapd_set_read( s, 1 );
+	if ( ber_pvt_sb_needs_write( c->c_sb ) )
+		slapd_set_write( s, 1 );
 	connection_return( c );
 	ldap_pvt_thread_mutex_unlock( &connections_mutex );
 	return 0;
@@ -802,11 +930,10 @@ connection_input(
 		return -1;
 	}
 
-#ifdef LDAP_COMPAT30
-	if ( conn->c_version == 30 ) {
-		(void) ber_skip_tag( ber, &len );
+	if(tag == LDAP_REQ_BIND) {
+		/* immediately abandon all exiting operations upon BIND */
+		connection_abandon( conn );
 	}
-#endif
 
 	op = slap_op_alloc( ber, msgid, tag, conn->c_n_ops_received++ );
 
@@ -814,9 +941,11 @@ connection_input(
 		|| conn->c_conn_state == SLAP_C_CLOSING )
 	{
 		Debug( LDAP_DEBUG_ANY, "deferring operation\n", 0, 0, 0 );
+		conn->c_n_ops_pending++;
 		slap_op_add( &conn->c_pending_ops, op );
 
 	} else {
+		conn->c_n_ops_executing++;
 		connection_op_activate( conn, op );
 	}
 
@@ -857,6 +986,9 @@ connection_resched( Connection *conn )
 		/* pending operations should not be marked for abandonment */
 		assert(!op->o_abandon);
 
+		conn->c_n_ops_pending--;
+		conn->c_n_ops_executing++;
+
 		connection_op_activate( conn, op );
 
 		if ( conn->c_conn_state == SLAP_C_BINDING ) {
@@ -873,6 +1005,10 @@ static int connection_op_activate( Connection *conn, Operation *op )
 	int status;
 	ber_tag_t tag = op->o_tag;
 
+	if(tag == LDAP_REQ_BIND) {
+		conn->c_conn_state = SLAP_C_BINDING;
+	}
+
 	if ( conn->c_dn != NULL ) {
 		tmpdn = ch_strdup( conn->c_dn );
 	} else {
@@ -883,16 +1019,22 @@ static int connection_op_activate( Connection *conn, Operation *op )
 	arg->co_conn = conn;
 	arg->co_op = op;
 
+	arg->co_op->o_bind_in_progress = conn->c_bind_in_progress;
+
 	arg->co_op->o_dn = ch_strdup( tmpdn != NULL ? tmpdn : "" );
-	arg->co_op->o_ndn = dn_normalize_case( ch_strdup( arg->co_op->o_dn ) );
+	arg->co_op->o_ndn = ch_strdup( arg->co_op->o_dn );
+	(void) dn_normalize_case( arg->co_op->o_ndn );
 
-	slap_op_add( &conn->c_ops, arg->co_op );
+	arg->co_op->o_protocol = conn->c_protocol;
+	arg->co_op->o_connid = conn->c_connid;
 
-	if(tag == LDAP_REQ_BIND) {
-		conn->c_conn_state = SLAP_C_BINDING;
-	}
+	arg->co_op->o_authtype = conn->c_authtype;
+	arg->co_op->o_authmech = conn->c_authmech != NULL
+		?  ch_strdup( conn->c_authmech ) : NULL;
+	
+	slap_op_add( &conn->c_ops, arg->co_op );
 
-	if ( tmpdn != NULL ) {
+	if( tmpdn != NULL ) {
 		free( tmpdn );
 	}
 
@@ -933,12 +1075,18 @@ int connection_write(ber_socket_t s)
 		return -1;
 	}
 
+	c->c_n_write++;
+
 	Debug( LDAP_DEBUG_TRACE,
 		"connection_write(%d): waking output for id=%ld\n",
 		s, c->c_connid, 0 );
 
 	ldap_pvt_thread_cond_signal( &c->c_write_cv );
 
+	if ( ber_pvt_sb_needs_read( c->c_sb ) )
+		slapd_set_read( s, 1 );
+	if ( ber_pvt_sb_needs_write( c->c_sb ) )
+		slapd_set_write( s, 1 );
 	connection_return( c );
 	ldap_pvt_thread_mutex_unlock( &connections_mutex );
 	return 0;