X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=servers%2Fslapd%2Fconnection.c;h=16d9b429fb0fd617e2d31258944e8d986c8c11e9;hb=4361a942abb69d6b3dbae637cddb4055080fe6fa;hp=aa8f1bb2b693c920d8bde8e7d74957e9f9742ba1;hpb=4d0de8b3c53e7ed00c87e765bdca7df96fc4713e;p=openldap diff --git a/servers/slapd/connection.c b/servers/slapd/connection.c index aa8f1bb2b6..16d9b429fb 100644 --- a/servers/slapd/connection.c +++ b/servers/slapd/connection.c @@ -1,7 +1,7 @@ /* $OpenLDAP$ */ /* This work is part of OpenLDAP Software . * - * 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 @@ -43,19 +43,20 @@ #include "slapi/slapi.h" #endif - #ifdef SLAP_MULTI_CONN_ARRAY /* for Multiple Connection Arrary (MCA) Support */ static ldap_pvt_thread_mutex_t* connections_mutex; static Connection **connections = NULL; -/* set to the number of processors */ +/* set to the number of processors (round up to a power of 2) */ # define NUM_CONNECTION_ARRAY 4 /* partition the array in a modulo manner */ # define MCA_conn_array_id(fd) ((int)(fd)%NUM_CONNECTION_ARRAY) # define MCA_conn_array_element_id(fd) ((int)(fd)/NUM_CONNECTION_ARRAY) -# define MCA_GET_CONNECTION(fd) (&(connections[MCA_conn_array_id(fd)])\ +# define MCA_ARRAY_SIZE ((int)(MCA_conn_array_element_id(dtblsize) + (MCA_conn_array_id(dtblsize) ? 1 : 0))) +# define MCA_conn_check(fd) (dtblsize > 0 && (fd) >= 0 && (fd) < (MCA_ARRAY_SIZE*NUM_CONNECTION_ARRAY)) +# define MCA_GET_CONNECTION(fd) (&(connections[MCA_conn_array_id(fd)]) \ [MCA_conn_array_element_id(fd)]) # define MCA_GET_CONN_MUTEX(fd) (&connections_mutex[MCA_conn_array_id(fd)]) @@ -64,6 +65,7 @@ static Connection **connections = NULL; static ldap_pvt_thread_mutex_t connections_mutex; static Connection *connections = NULL; +# define MCA_conn_check(fd) (dtblsize > 0 && (fd) < dtblsize) # define MCA_GET_CONNECTION(fd) (&connections[s]) # define MCA_GET_CONN_MUTEX(fd) (&connections_mutex) #endif @@ -103,15 +105,23 @@ connection_state2str( int state ) static Connection* connection_get( ber_socket_t s ); -#ifdef SLAP_LIGHTWEIGHT_LISTENER -static int connection_input( Connection *c, Operation** op ); +#ifdef SLAP_LIGHTWEIGHT_DISPATCHER + +typedef struct conn_readinfo { + Operation *op; + ldap_pvt_thread_start_t *func; + void *arg; + int nullop; +} conn_readinfo; + +static int connection_input( Connection *c, conn_readinfo *cri ); #else static int connection_input( Connection *c ); #endif static void connection_close( Connection *c ); static int connection_op_activate( Operation *op ); -#ifdef SLAP_LIGHTWEIGHT_LISTENER +#ifdef SLAP_LIGHTWEIGHT_DISPATCHER static void connection_op_queue( Operation *op ); #endif static int connection_resched( Connection *conn ); @@ -126,8 +136,8 @@ static ldap_pvt_thread_start_t connection_operation; int connections_init(void) #ifdef SLAP_MULTI_CONN_ARRAY { - int i, j; - Connection* conn; + int i, j; + Connection* conn; assert( connections == NULL ); @@ -137,26 +147,29 @@ int connections_init(void) return -1; } - connections_mutex = (ldap_pvt_thread_mutex_t*) ch_calloc( NUM_CONNECTION_ARRAY, sizeof(ldap_pvt_thread_mutex_t) ); + connections_mutex = (ldap_pvt_thread_mutex_t*) ch_calloc( + NUM_CONNECTION_ARRAY, sizeof(ldap_pvt_thread_mutex_t) ); if( connections_mutex == NULL ) { - Debug( LDAP_DEBUG_ANY, - "connections_init: allocation of connection mutex[%d] failed\n", i, 0, 0 ); + Debug( LDAP_DEBUG_ANY, "connections_init: " + "allocation of connection mutexes failed\n", 0, 0, 0 ); return -1; } - connections = (Connection**) ch_calloc( NUM_CONNECTION_ARRAY, sizeof(Connection*)); + connections = (Connection**) ch_calloc( + NUM_CONNECTION_ARRAY, sizeof(Connection*)); if( connections == NULL ) { - Debug( LDAP_DEBUG_ANY, - "connections_init: allocation of connection[%d] failed\n", 0, 0, 0 ); + Debug( LDAP_DEBUG_ANY, "connections_init: " + "allocation of connection[%d] failed\n", 0, 0, 0 ); return -1; } for ( i = 0; i < NUM_CONNECTION_ARRAY; i++ ) { ldap_pvt_thread_mutex_init( connections_mutex+i ); - connections[i] = (Connection*) ch_calloc( (dtblsize/NUM_CONNECTION_ARRAY), sizeof(Connection) ); + connections[i] = (Connection*) ch_calloc( + MCA_ARRAY_SIZE, sizeof(Connection) ); if( connections[i] == NULL ) { - Debug( LDAP_DEBUG_ANY, - "connections_init: allocation (%d*%ld) of connection array[%d] failed\n", + Debug( LDAP_DEBUG_ANY, "connections_init: " + "allocation (%d*%ld) of connection array[%d] failed\n", dtblsize, (long) sizeof(Connection), i ); return -1; } @@ -166,11 +179,12 @@ int connections_init(void) ldap_pvt_thread_mutex_init( &conn_nextid_mutex ); assert( connections[0]->c_struct_state == SLAP_C_UNINITIALIZED ); - assert( connections[NUM_CONNECTION_ARRAY-1]->c_struct_state == SLAP_C_UNINITIALIZED ); + assert( connections[NUM_CONNECTION_ARRAY-1]->c_struct_state == + SLAP_C_UNINITIALIZED ); for ( i = 0; i < NUM_CONNECTION_ARRAY; i++ ) { conn = connections[i]; - for ( j = 0; j < (dtblsize/NUM_CONNECTION_ARRAY); j++ ) { + for ( j = 0; j < MCA_ARRAY_SIZE; j++ ) { conn[j].c_conn_idx = j; } } @@ -201,8 +215,8 @@ int connections_init(void) connections = (Connection *) ch_calloc( dtblsize, sizeof(Connection) ); if( connections == NULL ) { - Debug( LDAP_DEBUG_ANY, - "connections_init: allocation (%d*%ld) of connection array failed\n", + Debug( LDAP_DEBUG_ANY, "connections_init: " + "allocation (%d*%ld) of connection array failed\n", dtblsize, (long) sizeof(Connection), 0 ); return -1; } @@ -239,7 +253,7 @@ int connections_destroy(void) for ( i = 0; i < NUM_CONNECTION_ARRAY; i++ ) { Connection* conn = connections[i]; - for ( j = 0; j < (dtblsize/NUM_CONNECTION_ARRAY); j++ ) { + for ( j = 0; j < MCA_ARRAY_SIZE; j++ ) { if( conn[j].c_struct_state != SLAP_C_UNINITIALIZED ) { ber_sockbuf_free( conn[j].c_sb ); ldap_pvt_thread_mutex_destroy( &conn[j].c_mutex ); @@ -262,6 +276,9 @@ int connections_destroy(void) ldap_pvt_thread_mutex_destroy( &connections_mutex[i] ); } + free( connections ); + free( connections_mutex ); + ldap_pvt_thread_mutex_destroy( &conn_nextid_mutex ); return 0; @@ -315,7 +332,7 @@ int connections_shutdown(void) for ( i = 0; i < NUM_CONNECTION_ARRAY; i++ ) { Connection* conn = connections[i]; ldap_pvt_thread_mutex_lock( &connections_mutex[i] ); - for ( j = 0; j < (dtblsize/NUM_CONNECTION_ARRAY); j++ ) { + for ( j = 0; j < MCA_ARRAY_SIZE; j++ ) { if( conn[j].c_struct_state != SLAP_C_USED ) { continue; } @@ -386,8 +403,9 @@ int connections_timeout_idle(time_t now) { /* Don't timeout a slow-running request or a persistent * outbound connection */ - if( c->c_n_ops_executing || - c->c_conn_state == SLAP_C_CLIENT ) continue; + if( c->c_n_ops_executing || c->c_conn_state == SLAP_C_CLIENT ) { + continue; + } if( difftime( c->c_activitytime+global_idletimeout, now) < 0 ) { /* close it */ @@ -413,11 +431,10 @@ static Connection* connection_get( ber_socket_t s ) assert( connections != NULL ); - if(s == AC_SOCKET_INVALID) { - return NULL; - } + if(s == AC_SOCKET_INVALID) return NULL; #ifndef HAVE_WINSOCK + assert( MCA_conn_check( s ) ); c = MCA_GET_CONNECTION(s); assert( c->c_struct_state != SLAP_C_UNINITIALIZED ); @@ -537,6 +554,7 @@ long connection_init( ldap_pvt_thread_mutex_lock( MCA_GET_CONN_MUTEX(s) ); #ifndef HAVE_WINSOCK + assert( MCA_conn_check( s ) ); c = MCA_GET_CONNECTION(s); #else { @@ -564,9 +582,7 @@ long connection_init( break; } - if( connections[i].c_conn_state == SLAP_C_CLIENT ) { - continue; - } + if( connections[i].c_conn_state == SLAP_C_CLIENT ) continue; assert( connections[i].c_struct_state == SLAP_C_USED ); assert( connections[i].c_conn_state != SLAP_C_INVALID ); @@ -590,9 +606,7 @@ long connection_init( c->c_send_search_entry = slap_send_search_entry; c->c_send_search_reference = slap_send_search_reference; c->c_send_ldap_extended = slap_send_ldap_extended; -#ifdef LDAP_RES_INTERMEDIATE c->c_send_ldap_intermediate = slap_send_ldap_intermediate; -#endif BER_BVZERO( &c->c_authmech ); BER_BVZERO( &c->c_dn ); @@ -750,6 +764,7 @@ long connection_init( slap_sasl_open( c, 0 ); slap_sasl_external( c, ssf, authid ); + slapd_add_internal( s, 1 ); ldap_pvt_thread_mutex_unlock( &c->c_mutex ); ldap_pvt_thread_mutex_unlock( MCA_GET_CONN_MUTEX(s) ); @@ -843,17 +858,19 @@ connection_destroy( Connection *c ) } ber_sockbuf_ctrl( c->c_sb, LBER_SB_OPT_GET_FD, &sd ); + slapd_sd_lock(); + ber_sockbuf_free( c->c_sb ); if ( sd != AC_SOCKET_INVALID ) { - slapd_remove( sd, 1, 0 ); + slapd_remove( sd, 1, 0, 1 ); Statslog( LDAP_DEBUG_STATS, (close_reason ? "conn=%lu fd=%ld closed (%s)\n" : "conn=%lu fd=%ld closed\n"), connid, (long) sd, close_reason, 0, 0 ); + } else { + slapd_sd_unlock(); } - ber_sockbuf_free( c->c_sb ); - c->c_sb = ber_sockbuf_alloc( ); { @@ -1026,15 +1043,14 @@ Connection* connection_next( Connection *c, ber_socket_t *index ) assert( connections != NULL ); assert( index != NULL ); - assert( *index <= (dtblsize/NUM_CONNECTION_ARRAY) ); + assert( *index >= 0 && *index < MCA_ARRAY_SIZE ); - if( c != NULL ) { - ldap_pvt_thread_mutex_unlock( &c->c_mutex ); - } + if( c != NULL ) ldap_pvt_thread_mutex_unlock( &c->c_mutex ); c = NULL; for(; *index < dtblsize; (*index)++) { + assert( MCA_conn_check( *index ) ); conn = MCA_GET_CONNECTION(*index); if( conn->c_struct_state == SLAP_C_UNINITIALIZED ) { assert( conn->c_conn_state == SLAP_C_INVALID ); @@ -1056,9 +1072,7 @@ Connection* connection_next( Connection *c, ber_socket_t *index ) assert( conn->c_conn_state == SLAP_C_INVALID ); } - if( c != NULL ) { - ldap_pvt_thread_mutex_lock( &c->c_mutex ); - } + if( c != NULL ) ldap_pvt_thread_mutex_lock( &c->c_mutex ); return c; @@ -1069,9 +1083,7 @@ Connection* connection_next( Connection *c, ber_socket_t *index ) assert( index != NULL ); assert( *index <= dtblsize ); - if( c != NULL ) { - ldap_pvt_thread_mutex_unlock( &c->c_mutex ); - } + if( c != NULL ) ldap_pvt_thread_mutex_unlock( &c->c_mutex ); c = NULL; @@ -1095,10 +1107,7 @@ Connection* connection_next( Connection *c, ber_socket_t *index ) assert( connections[*index].c_conn_state == SLAP_C_INVALID ); } - if( c != NULL ) { - ldap_pvt_thread_mutex_lock( &c->c_mutex ); - } - + if( c != NULL ) ldap_pvt_thread_mutex_lock( &c->c_mutex ); return c; } #endif @@ -1111,9 +1120,7 @@ void connection_done( Connection *c ) assert( connections != NULL ); - if( c != NULL ) { - ldap_pvt_thread_mutex_unlock( &c->c_mutex ); - } + if( c != NULL ) ldap_pvt_thread_mutex_unlock( &c->c_mutex ); #ifdef SLAP_MULTI_CONN_ARRAY for ( conn_array_id = 0; @@ -1311,10 +1318,11 @@ operations_error: } if ( op->o_cancel == SLAP_CANCEL_REQ ) { - if ( rc == SLAPD_ABANDON ) + if ( rc == SLAPD_ABANDON ) { op->o_cancel = SLAP_CANCEL_ACK; - else + } else { op->o_cancel = LDAP_TOO_LATE; + } } while ( op->o_cancel != SLAP_CANCEL_NONE && op->o_cancel != SLAP_CANCEL_DONE ) @@ -1336,17 +1344,9 @@ operations_error: case LBER_ERROR: case LDAP_REQ_UNBIND: /* c_mutex is locked */ - connection_closing( - conn, tag == LDAP_REQ_UNBIND ? NULL : "operations error" ); + connection_closing( conn, + tag == LDAP_REQ_UNBIND ? NULL : "operations error" ); break; - - case LDAP_REQ_BIND: - conn->c_sasl_bind_in_progress = - rc == LDAP_SASL_BIND_IN_PROGRESS ? 1 : 0; - - if( conn->c_conn_state == SLAP_C_BINDING) { - conn->c_conn_state = SLAP_C_ACTIVE; - } } connection_resched( conn ); @@ -1371,9 +1371,10 @@ int connection_client_setup( c = connection_get( s ); c->c_clientfunc = func; c->c_clientarg = arg; - connection_return( c ); + slapd_add_internal( s, 0 ); slapd_set_read( s, 1 ); + connection_return( c ); return 0; } @@ -1397,7 +1398,9 @@ void connection_client_stop( c->c_conn_state = SLAP_C_INVALID; c->c_struct_state = SLAP_C_UNUSED; c->c_close_reason = "?"; /* should never be needed */ + slapd_sd_lock(); ber_sockbuf_free( c->c_sb ); + slapd_remove( s, 0, 1, 1 ); c->c_sb = ber_sockbuf_alloc( ); { ber_len_t max = sockbuf_max_incoming; @@ -1405,71 +1408,72 @@ void connection_client_stop( } connection_return( c ); - slapd_remove( s, 0, 1 ); } -#ifdef SLAP_LIGHTWEIGHT_LISTENER -void* connection_processing_thread( void* ctx, void* argv ) +#ifdef SLAP_LIGHTWEIGHT_DISPATCHER + +static int connection_read( ber_socket_t s, conn_readinfo *cri ); + +static void* connection_read_thread( void* ctx, void* argv ) { int rc ; - Operation* new_op = NULL; - ber_socket_t s = (ber_socket_t)argv; + conn_readinfo cri = { NULL, NULL, NULL, 0 }; + ber_socket_t s = (long)argv; /* * read incoming LDAP requests. If there is more than one, * the first one is returned with new_op */ - if( ( rc = connection_read( s, &new_op ) ) < 0 ) { - Debug( LDAP_DEBUG_TRACE, "connection_read(%d) error\n", s, 0, 0 ); - tcp_close( s ); - return (void*)rc; + if( ( rc = connection_read( s, &cri ) ) < 0 ) { + Debug( LDAP_DEBUG_CONNS, "connection_read(%d) error\n", s, 0, 0 ); + return (void*)(long)rc; } - /* execute the queued request in the same thread */ - if( new_op ) { - rc = (int)connection_operation( - ldap_pvt_thread_pool_context(), new_op ); + /* execute a single queued request in the same thread */ + if( cri.op && !cri.nullop ) { + rc = (long)connection_operation( ctx, cri.op ); + } else if ( cri.func ) { + rc = (long)cri.func( ctx, cri.arg ); } - return (void*)rc; + return (void*)(long)rc; } -int connection_processing_activate( ber_socket_t s ) +int connection_read_activate( ber_socket_t s ) { - int status; + int rc; /* * suspend reading on this file descriptor until a connection processing * thread reads data on it. Otherwise the listener thread will repeatedly * submit the same event on it to the pool. */ - if( !slapd_suspend( s ) ) return 0; + rc = slapd_clr_read( s, 0 ); + if ( rc ) + return rc; - status = ldap_pvt_thread_pool_submit( &connection_pool, - connection_processing_thread, (void *) s ); + rc = ldap_pvt_thread_pool_submit( &connection_pool, + connection_read_thread, (void *)(long)s ); - if( status != 0 ) { - Debug( LDAP_DEBUG_ANY, "connection_processing_activiate(%d): " - "ldap_pvt_thread_pool_submit failed\n", - s, 0, 0 ); - return -1; + if( rc != 0 ) { + Debug( LDAP_DEBUG_ANY, + "connection_read_activate(%d): submit failed (%d)\n", + s, rc, 0 ); } - return 1; + return rc; } #endif -#ifdef SLAP_LIGHTWEIGHT_LISTENER -int connection_read( ber_socket_t s, Operation** op ) +#ifdef SLAP_LIGHTWEIGHT_DISPATCHER +static int +connection_read( ber_socket_t s, conn_readinfo *cri ) #else int connection_read(ber_socket_t s) #endif { int rc = 0; Connection *c; -#ifdef SLAP_LIGHTWEIGHT_LISTENER - int need_resume = 1; -#endif assert( connections != NULL ); @@ -1482,7 +1486,6 @@ int connection_read(ber_socket_t s) Debug( LDAP_DEBUG_ANY, "connection_read(%ld): no connection!\n", (long) s, 0, 0 ); - slapd_remove(s, 1, 0); ldap_pvt_thread_mutex_unlock( MCA_GET_CONN_MUTEX(s) ); return -1; @@ -1494,23 +1497,25 @@ int connection_read(ber_socket_t s) Debug( LDAP_DEBUG_TRACE, "connection_read(%d): closing, ignoring input for id=%lu\n", s, c->c_connid, 0 ); - connection_return( c ); - ldap_pvt_thread_mutex_unlock( MCA_GET_CONN_MUTEX(s) ); -#ifdef SLAP_LIGHTWEIGHT_LISTENER - slapd_resume( s ); +#ifdef SLAP_LIGHTWEIGHT_DISPATCHER + slapd_set_read( s, 1 ); #endif + connection_return( c ); + ldap_pvt_thread_mutex_unlock( MCA_GET_CONN_MUTEX(s) ); return 0; } if ( c->c_conn_state == SLAP_C_CLIENT ) { -#ifdef SLAP_LIGHTWEIGHT_LISTENER - slapd_resume( s ); -#endif +#ifdef SLAP_LIGHTWEIGHT_DISPATCHER + cri->func = c->c_clientfunc; + cri->arg = c->c_clientarg; + /* read should already be cleared */ +#else slapd_clr_read( s, 0 ); ldap_pvt_thread_pool_submit( &connection_pool, c->c_clientfunc, c->c_clientarg ); - +#endif connection_return( c ); ldap_pvt_thread_mutex_unlock( MCA_GET_CONN_MUTEX(s) ); return 0; @@ -1525,7 +1530,7 @@ int connection_read(ber_socket_t s) rc = ldap_pvt_tls_accept( c->c_sb, slap_tls_ctx ); if ( rc < 0 ) { Debug( LDAP_DEBUG_TRACE, - "connection_read(%d): TLS accept error " + "connection_read(%d): TLS accept failure " "error=%d id=%lu, closing\n", s, rc, c->c_connid ); @@ -1553,6 +1558,9 @@ int connection_read(ber_socket_t s) #endif connection_close( c ); + connection_return( c ); + ldap_pvt_thread_mutex_unlock( MCA_GET_CONN_MUTEX(s) ); + return 0; } else if ( rc == 0 ) { void *ssl; @@ -1585,12 +1593,12 @@ int connection_read(ber_socket_t s) if( rc != 0 || !ber_sockbuf_ctrl( c->c_sb, LBER_SB_OPT_DATA_READY, NULL ) ) { +#ifdef SLAP_LIGHTWEIGHT_DISPATCHER + slapd_set_read( s, 1 ); +#endif + connection_return( c ); ldap_pvt_thread_mutex_unlock( MCA_GET_CONN_MUTEX(s) ); - -#ifdef SLAP_LIGHTWEIGHT_LISTENER - slapd_resume( s ); -#endif return 0; } } @@ -1600,12 +1608,12 @@ int connection_read(ber_socket_t s) if ( c->c_sasl_layers ) { /* If previous layer is not removed yet, give up for now */ if ( !c->c_sasl_sockctx ) { +#ifdef SLAP_LIGHTWEIGHT_DISPATCHER + slapd_set_read( s, 1 ); +#endif + connection_return( c ); ldap_pvt_thread_mutex_unlock( MCA_GET_CONN_MUTEX(s) ); - -#ifdef SLAP_LIGHTWEIGHT_LISTENER - slapd_resume( s ); -#endif return 0; } @@ -1619,10 +1627,6 @@ int connection_read(ber_socket_t s) s, rc, c->c_connid ); /* connections_mutex and c_mutex are locked */ - -#ifdef SLAP_LIGHTWEIGHT_LISTENER - slapd_resume( s ); -#endif connection_closing( c, "SASL layer install failure" ); connection_close( c ); connection_return( c ); @@ -1637,22 +1641,11 @@ int connection_read(ber_socket_t s) do { /* How do we do this without getting into a busy loop ? */ -#ifdef SLAP_LIGHTWEIGHT_LISTENER - rc = connection_input( c, op ); +#ifdef SLAP_LIGHTWEIGHT_DISPATCHER + rc = connection_input( c, cri ); #else rc = connection_input( c ); #endif - -#ifdef SLAP_LIGHTWEIGHT_LISTENER - if( *op && (*op)->o_tag == LDAP_REQ_UNBIND ) { - /* - * After the reception of an unbind request, - * no more incoming requests via the connection - * is expected. Therefore, don't resume connection reading. - */ - need_resume = 0; - } -#endif } #ifdef DATA_READY_LOOP while( !rc && ber_sockbuf_ctrl( c->c_sb, LBER_SB_OPT_DATA_READY, NULL )); @@ -1675,10 +1668,13 @@ int connection_read(ber_socket_t s) return 0; } -#ifdef SLAP_LIGHTWEIGHT_LISTENER - if ( need_resume ) slapd_resume( s ); -#endif +#ifdef SLAP_LIGHTWEIGHT_DISPATCHER + if ( ber_sockbuf_ctrl( c->c_sb, LBER_SB_OPT_NEEDS_WRITE, NULL ) ) { + slapd_set_write( s, 0 ); + } + slapd_set_read( s, 1 ); +#else if ( ber_sockbuf_ctrl( c->c_sb, LBER_SB_OPT_NEEDS_READ, NULL ) ) { slapd_set_read( s, 1 ); } @@ -1686,6 +1682,7 @@ int connection_read(ber_socket_t s) if ( ber_sockbuf_ctrl( c->c_sb, LBER_SB_OPT_NEEDS_WRITE, NULL ) ) { slapd_set_write( s, 1 ); } +#endif connection_return( c ); ldap_pvt_thread_mutex_unlock( MCA_GET_CONN_MUTEX(s) ); @@ -1694,8 +1691,8 @@ int connection_read(ber_socket_t s) } static int -#ifdef SLAP_LIGHTWEIGHT_LISTENER -connection_input( Connection *conn , Operation** c_op ) +#ifdef SLAP_LIGHTWEIGHT_DISPATCHER +connection_input( Connection *conn , conn_readinfo *cri ) #else connection_input( Connection *conn ) #endif @@ -1884,21 +1881,28 @@ connection_input( Connection *conn ) } else { conn->c_n_ops_executing++; -#ifdef SLAP_LIGHTWEIGHT_LISTENER +#ifdef SLAP_LIGHTWEIGHT_DISPATCHER /* * The first op will be processed in the same thread context, + * as long as there is only one op total. * Subsequent ops will be submitted to the pool by * calling connection_op_activate() */ - if ( *c_op == NULL ) { + if ( cri->op == NULL ) { /* the first incoming request */ connection_op_queue( op ); - *c_op = op; - } else -#endif - { + cri->op = op; + } else { + if ( !cri->nullop ) { + cri->nullop = 1; + rc = ldap_pvt_thread_pool_submit( &connection_pool, + connection_operation, (void *) cri->op ); + } connection_op_activate( op ); } +#else + connection_op_activate( op ); +#endif } #ifdef NO_THREADS @@ -1991,12 +1995,77 @@ connection_init_log_prefix( Operation *op ) } } +static int connection_bind_cb( Operation *op, SlapReply *rs ) +{ + slap_callback *cb = op->o_callback; + + ldap_pvt_thread_mutex_lock( &op->o_conn->c_mutex ); + op->o_conn->c_conn_state = SLAP_C_ACTIVE; + op->o_conn->c_sasl_bind_in_progress = + ( rs->sr_err == LDAP_SASL_BIND_IN_PROGRESS ); + + /* Moved here from bind.c due to ITS#4158 */ + op->o_conn->c_sasl_bindop = NULL; + if ( op->orb_method == LDAP_AUTH_SASL ) { + if( rs->sr_err == LDAP_SUCCESS ) { + ber_dupbv(&op->o_conn->c_dn, &op->orb_edn); + if( !BER_BVISEMPTY( &op->orb_edn ) ) { + /* edn is always normalized already */ + ber_dupbv( &op->o_conn->c_ndn, &op->o_conn->c_dn ); + } + op->o_tmpfree( op->orb_edn.bv_val, op->o_tmpmemctx ); + BER_BVZERO( &op->orb_edn ); + op->o_conn->c_authmech = op->o_conn->c_sasl_bind_mech; + BER_BVZERO( &op->o_conn->c_sasl_bind_mech ); + + op->o_conn->c_sasl_ssf = op->orb_ssf; + if( op->orb_ssf > op->o_conn->c_ssf ) { + op->o_conn->c_ssf = op->orb_ssf; + } + + if( !BER_BVISEMPTY( &op->o_conn->c_dn ) ) { + ber_len_t max = sockbuf_max_incoming_auth; + ber_sockbuf_ctrl( op->o_conn->c_sb, + LBER_SB_OPT_SET_MAX_INCOMING, &max ); + } + + /* log authorization identity */ + Statslog( LDAP_DEBUG_STATS, + "%s BIND dn=\"%s\" mech=%s ssf=%d\n", + op->o_log_prefix, + BER_BVISNULL( &op->o_conn->c_dn ) ? "" : op->o_conn->c_dn.bv_val, + op->o_conn->c_authmech.bv_val, op->orb_ssf, 0 ); + + Debug( LDAP_DEBUG_TRACE, + "do_bind: SASL/%s bind: dn=\"%s\" ssf=%d\n", + op->o_conn->c_authmech.bv_val, + BER_BVISNULL( &op->o_conn->c_dn ) ? "" : op->o_conn->c_dn.bv_val, + op->orb_ssf ); + + } else if ( rs->sr_err != LDAP_SASL_BIND_IN_PROGRESS ) { + if ( !BER_BVISNULL( &op->o_conn->c_sasl_bind_mech ) ) { + free( op->o_conn->c_sasl_bind_mech.bv_val ); + BER_BVZERO( &op->o_conn->c_sasl_bind_mech ); + } + } + } + ldap_pvt_thread_mutex_unlock( &op->o_conn->c_mutex ); + + ch_free( op->o_callback ); + op->o_callback = NULL; + + return SLAP_CB_CONTINUE; +} + static void connection_op_queue( Operation *op ) { - int status; ber_tag_t tag = op->o_tag; if (tag == LDAP_REQ_BIND) { + slap_callback *sc = ch_calloc( 1, sizeof( slap_callback )); + sc->sc_response = connection_bind_cb; + sc->sc_next = op->o_callback; + op->o_callback = sc; op->o_conn->c_conn_state = SLAP_C_BINDING; } @@ -2033,24 +2102,54 @@ static void connection_op_queue( Operation *op ) static int connection_op_activate( Operation *op ) { - int status; - ber_tag_t tag = op->o_tag; + int rc; connection_op_queue( op ); - status = ldap_pvt_thread_pool_submit( &connection_pool, + rc = ldap_pvt_thread_pool_submit( &connection_pool, connection_operation, (void *) op ); - if ( status != 0 ) { + if ( rc != 0 ) { Debug( LDAP_DEBUG_ANY, - "ldap_pvt_thread_pool_submit: failed (%d) for conn=%lu\n", - status, op->o_connid, 0 ); + "connection_op_activate: submit failed (%d) for conn=%lu\n", + rc, op->o_connid, 0 ); /* should move op to pending list */ } - return status; + return rc; +} + +#ifdef SLAP_LIGHTWEIGHT_DISPATCHER +static int connection_write( ber_socket_t s ); +static void *connection_write_thread( void *ctx, void *arg ) +{ + return (void *)(long)connection_write((long)arg); +} + +int connection_write_activate( ber_socket_t s ) +{ + int rc; + + /* + * suspend reading on this file descriptor until a connection processing + * thread write data on it. Otherwise the listener thread will repeatedly + * submit the same event on it to the pool. + */ + slapd_clr_write( s, 0); + + rc = ldap_pvt_thread_pool_submit( &connection_pool, + connection_write_thread, (void *)(long)s ); + + if( rc != 0 ) { + Debug( LDAP_DEBUG_ANY, + "connection_write_activate(%d): submit failed (%d)\n", + (int) s, rc, 0 ); + } + return rc; } +static +#endif int connection_write(ber_socket_t s) { Connection *c; @@ -2065,12 +2164,13 @@ int connection_write(ber_socket_t s) Debug( LDAP_DEBUG_ANY, "connection_write(%ld): no connection!\n", (long)s, 0, 0 ); - slapd_remove(s, 1, 0); ldap_pvt_thread_mutex_unlock( MCA_GET_CONN_MUTEX( s ) ); return -1; } +#ifndef SLAP_LIGHTWEIGHT_DISPATCHER slapd_clr_write( s, 0); +#endif c->c_n_write++; Debug( LDAP_DEBUG_TRACE, @@ -2105,10 +2205,9 @@ int connection_write(ber_socket_t s) break; } - connection_return( c ); + connection_return( c ); ldap_pvt_thread_mutex_unlock( MCA_GET_CONN_MUTEX(s) ); - return 0; } @@ -2138,7 +2237,12 @@ connection_fake_init( op->o_connid = op->o_conn->c_connid; connection_init_log_prefix( op ); - op->o_time = slap_get_time(); +#ifdef LDAP_SLAPI + slapi_int_create_object_extensions( SLAPI_X_EXT_CONNECTION, conn ); + slapi_int_create_object_extensions( SLAPI_X_EXT_OPERATION, op ); +#endif /* LDAP_SLAPI */ + + slap_op_time( &op->o_time, &op->o_tincr ); } void