/* $OpenLDAP$ */
-/*
- * Copyright 1998-2003 The OpenLDAP Foundation, All Rights Reserved.
- * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
+/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
+ *
+ * Copyright 1998-2004 The OpenLDAP Foundation.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted only as authorized by the OpenLDAP
+ * Public License.
+ *
+ * A copy of this license is available in the file LICENSE in the
+ * top-level directory of the distribution or, alternatively, at
+ * <http://www.OpenLDAP.org/license.html>.
+ */
+/* Portions Copyright (c) 1995 Regents of the University of Michigan.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that this notice is preserved and that due credit is given
+ * to the University of Michigan at Ann Arbor. The name of the University
+ * may not be used to endorse or promote products derived from this
+ * software without specific prior written permission. This software
+ * is provided ``as is'' without express or implied warranty.
*/
#include "portable.h"
#include "slap.h"
#ifdef LDAP_SLAPI
-#include "slapi.h"
+#include "slapi/slapi.h"
#endif
/* protected by connections_mutex */
*/
int connections_init(void)
{
+ int i;
+
assert( connections == NULL );
if( connections != NULL) {
assert( connections[0].c_struct_state == SLAP_C_UNINITIALIZED );
assert( connections[dtblsize-1].c_struct_state == SLAP_C_UNINITIALIZED );
+ for (i=0; i<dtblsize; i++) connections[i].c_conn_idx = i;
+
/*
* per entry initialization of the Connection array initialization
* will be done by connection_init()
ldap_pvt_thread_cond_destroy( &connections[i].c_write_cv );
#ifdef LDAP_SLAPI
if ( slapi_plugins_used ) {
- slapi_x_free_object_extensions( SLAPI_X_EXT_CONNECTION, &connections[i] );
+ slapi_int_free_object_extensions( SLAPI_X_EXT_CONNECTION, &connections[i] );
}
#endif
}
ldap_pvt_thread_mutex_unlock( &c->c_mutex );
return NULL;
}
- if( c->c_conn_state == SLAP_C_CLIENT ) sd = 0;
#ifdef NEW_LOGGING
LDAP_LOG( CONNECTION, RESULTS,
const char* peername,
int flags,
slap_ssf_t ssf,
- const char *authid )
+ struct berval *authid )
{
unsigned long id;
Connection *c;
break;
}
+ 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 );
assert( sd != AC_SOCKET_INVALID );
#ifdef LDAP_SLAPI
if ( slapi_plugins_used ) {
- slapi_x_create_object_extensions( SLAPI_X_EXT_CONNECTION, c );
+ slapi_int_create_object_extensions( SLAPI_X_EXT_CONNECTION, c );
}
#endif
if ( flags == CONN_IS_CLIENT ) {
c->c_conn_state = SLAP_C_CLIENT;
c->c_struct_state = SLAP_C_USED;
+ ber_sockbuf_ctrl( c->c_sb, LBER_SB_OPT_SET_FD, &s );
ldap_pvt_thread_mutex_unlock( &c->c_mutex );
ldap_pvt_thread_mutex_unlock( &connections_mutex );
assert( c->c_struct_state != SLAP_C_UNUSED );
assert( c->c_conn_state != SLAP_C_INVALID );
assert( LDAP_STAILQ_EMPTY(&c->c_ops) );
+ assert( c->c_writewaiter == 0);
/* only for stats (print -1 as "%lu" may give unexpected results ;) */
connid = c->c_connid;
ber_sockbuf_ctrl( c->c_sb, LBER_SB_OPT_SET_MAX_INCOMING, &max );
}
- c->c_writewaiter = 0;
c->c_conn_state = SLAP_C_INVALID;
c->c_struct_state = SLAP_C_UNUSED;
#ifdef LDAP_SLAPI
/* call destructors, then constructors; avoids unnecessary allocation */
if ( slapi_plugins_used ) {
- slapi_x_clear_object_extensions( SLAPI_X_EXT_CONNECTION, c );
+ slapi_int_clear_object_extensions( SLAPI_X_EXT_CONNECTION, c );
}
#endif
}
/* We can use Thread-Local storage for most mallocs. We can
* also use TL for ber parsing, but not on Add or Modify.
*/
-#define SLAB_SIZE 1048576
#if 0
memsiz = ber_len( op->o_ber ) * 64;
- if ( SLAB_SIZE > memsiz ) memsiz = SLAB_SIZE;
+ if ( SLAP_SLAB_SIZE > memsiz ) memsiz = SLAP_SLAB_SIZE;
#endif
- memsiz = SLAB_SIZE;
+ memsiz = SLAP_SLAB_SIZE;
- memctx = sl_mem_create( memsiz, ctx );
+ memctx = slap_sl_mem_create( memsiz, ctx );
op->o_tmpmemctx = memctx;
- op->o_tmpmfuncs = &sl_mfuncs;
+ op->o_tmpmfuncs = &slap_sl_mfuncs;
if ( tag != LDAP_REQ_ADD && tag != LDAP_REQ_MODIFY ) {
/* Note - the ber and its buffer are already allocated from
* regular memory; this only affects subsequent mallocs that
#endif /* SLAPD_MONITOR */
ldap_pvt_thread_mutex_unlock( &num_ops_mutex );
-#ifdef LDAP_EXOP_X_CANCEL
if ( op->o_cancel == SLAP_CANCEL_REQ ) {
op->o_cancel = LDAP_TOO_LATE;
}
{
ldap_pvt_thread_yield();
}
-#endif
ldap_pvt_thread_mutex_lock( &conn->c_mutex );
if ( op->o_cancel != SLAP_CANCEL_ACK &&
( op->o_sync_mode & SLAP_SYNC_PERSIST ) ) {
- sl_mem_detach( ctx, memctx );
+ slap_sl_mem_detach( ctx, memctx );
} else if (( op->o_sync_slog_size != -1 )) {
- sl_mem_detach( ctx, memctx );
+ slap_sl_mem_detach( ctx, memctx );
LDAP_STAILQ_REMOVE( &conn->c_ops, op, slap_op, o_next);
LDAP_STAILQ_NEXT(op, o_next) = NULL;
conn->c_n_ops_executing--;
conn->c_n_ops_completed++;
}
-no_co_op_free:
-
switch( tag ) {
case LBER_ERROR:
case LDAP_REQ_UNBIND:
return NULL;
}
+static const Listener dummy_list = { {0, ""}, {0, ""} };
+
int connection_client_setup(
ber_socket_t s,
- Listener *l,
ldap_pvt_thread_start_t *func,
void *arg )
{
Connection *c;
- if ( connection_init( s, l, "", "", CONN_IS_CLIENT, 0, "" ) < 0 ) {
+ if ( connection_init( s, (Listener *)&dummy_list, "", "", CONN_IS_CLIENT, 0, NULL ) < 0 ) {
return -1;
}
#ifdef HAVE_TLS
if ( c->c_is_tls && c->c_needs_tls_accept ) {
- rc = ldap_pvt_tls_accept( c->c_sb, NULL );
+ rc = ldap_pvt_tls_accept( c->c_sb, slap_tls_ctx );
if ( rc < 0 ) {
#if 0 /* required by next #if 0 */
struct timeval tv;
} else if ( rc == 0 ) {
void *ssl;
- struct berval authid = { 0, NULL };
+ struct berval authid = BER_BVNULL;
c->c_needs_tls_accept = 0;
s, rc, c->c_connid );
#endif
}
- slap_sasl_external( c, c->c_tls_ssf, authid.bv_val );
- if ( authid.bv_val ) free( authid.bv_val );
+ slap_sasl_external( c, c->c_tls_ssf, &authid );
+ if ( authid.bv_val ) free( authid.bv_val );
}
/* if success and data is ready, fall thru to data input loop */
#define CONNECTION_INPUT_LOOP 1
/* #define DATA_READY_LOOP 1 */
- do
- {
+ do {
/* How do we do this without getting into a busy loop ? */
rc = connection_input( c );
}
#ifdef DATA_READY_LOOP
- while( !rc && ber_sockbuf_ctrl( c->c_sb, LBER_SB_OPT_DATA_READY, NULL ) );
+ while( !rc && ber_sockbuf_ctrl( c->c_sb, LBER_SB_OPT_DATA_READY, NULL ));
#elif CONNECTION_INPUT_LOOP
while(!rc);
#else
static int
connection_input(
- Connection *conn
-)
+ Connection *conn )
{
Operation *op;
ber_tag_t tag;
Sockaddr peeraddr;
char *cdn = NULL;
#endif
+ char *defer = NULL;
if ( conn->c_currentber == NULL &&
( conn->c_currentber = ber_alloc()) == NULL )
op->o_preread_attrs = NULL;
op->o_postread_attrs = NULL;
op->o_vrFilter = NULL;
-
-#ifdef LDAP_CONTROL_PAGEDRESULTS
op->o_pagedresults_state = conn->c_pagedresults_state;
-#endif
op->o_res_ber = NULL;
* Bind, or if it's closing. Also, don't let any single conn
* use up all the available threads, and don't execute if we're
* currently blocked on output. And don't execute if there are
- * already pending ops, let them go first.
- *
- * But always allow Abandon through; it won't cost much.
+ * already pending ops, let them go first. Abandon operations
+ * get exceptions to some, but not all, cases.
*/
- if ( tag != LDAP_REQ_ABANDON && (conn->c_conn_state == SLAP_C_BINDING
- || conn->c_conn_state == SLAP_C_CLOSING
- || conn->c_n_ops_executing >= connection_pool_max/2
- || conn->c_n_ops_pending
- || conn->c_writewaiter))
- {
+ if (tag != LDAP_REQ_ABANDON && conn->c_conn_state == SLAP_C_CLOSING) {
+ defer = "closing";
+ } else if (tag != LDAP_REQ_ABANDON && conn->c_writewaiter) {
+ defer = "awaiting write";
+ } else if (conn->c_n_ops_executing >= connection_pool_max/2) {
+ defer = "too many executing";
+ } else if (conn->c_conn_state == SLAP_C_BINDING) {
+ defer = "binding";
+ } else if (tag != LDAP_REQ_ABANDON && conn->c_n_ops_pending) {
+ defer = "pending operations";
+ }
+
+ if( defer ) {
int max = conn->c_dn.bv_len
? slap_conn_max_pending_auth
: slap_conn_max_pending;
#ifdef NEW_LOGGING
LDAP_LOG( CONNECTION, INFO,
- "connection_input: conn %lu deferring operation\n",
- conn->c_connid, 0, 0 );
+ "connection_input: conn %lu deferring operation: %s\n",
+ conn->c_connid, defer, 0 );
#else
Debug( LDAP_DEBUG_ANY,
- "connection_input: conn=%lu deferring operation\n",
- conn->c_connid, 0, 0 );
+ "connection_input: conn=%lu deferring operation: %s\n",
+ conn->c_connid, defer, 0 );
#endif
conn->c_n_ops_pending++;
LDAP_STAILQ_INSERT_TAIL( &conn->c_pending_ops, op, o_next );
return 0;
}
+void
+connection_fake_init(
+ Connection *conn,
+ Operation *op,
+ void *ctx )
+{
+ conn->c_connid = -1;
+ conn->c_send_ldap_result = slap_send_ldap_result;
+ conn->c_send_search_entry = slap_send_search_entry;
+ conn->c_send_search_reference = slap_send_search_reference;
+ conn->c_listener = (Listener *)&dummy_list;
+ conn->c_peer_name = slap_empty_bv;
+
+ /* set memory context */
+ op->o_tmpmemctx = slap_sl_mem_create( SLAP_SLAB_SIZE, ctx );
+ op->o_tmpmfuncs = &slap_sl_mfuncs;
+ op->o_threadctx = ctx;
+
+ op->o_conn = conn;
+ op->o_connid = op->o_conn->c_connid;
+
+ op->o_time = slap_get_time();
+}