openldap/servers/slapd/operation.c

218 lines
4.8 KiB
C
Raw Normal View History

1998-08-09 08:43:13 +08:00
/* operation.c - routines to deal with pending ldap operations */
/* $OpenLDAP$ */
2003-11-27 09:17:14 +08:00
/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
*
2007-01-03 04:00:42 +08:00
* Copyright 1998-2007 The OpenLDAP Foundation.
2003-11-27 09:17:14 +08:00
* 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.
1999-08-07 07:07:46 +08:00
*/
1998-08-09 08:43:13 +08:00
1998-10-25 09:41:42 +08:00
#include "portable.h"
1998-08-09 08:43:13 +08:00
#include <stdio.h>
1998-10-25 09:41:42 +08:00
#include <ac/string.h>
#include <ac/socket.h>
1998-08-09 08:43:13 +08:00
#include "slap.h"
2003-02-10 10:09:00 +08:00
#ifdef LDAP_SLAPI
#include "slapi/slapi.h"
2003-02-10 10:09:00 +08:00
#endif
1998-08-09 08:43:13 +08:00
static ldap_pvt_thread_mutex_t slap_op_mutex;
static time_t last_time;
static int last_incr;
2003-03-29 19:46:02 +08:00
void slap_op_init(void)
{
ldap_pvt_thread_mutex_init( &slap_op_mutex );
}
2003-03-29 19:46:02 +08:00
void slap_op_destroy(void)
{
ldap_pvt_thread_mutex_destroy( &slap_op_mutex );
}
static void
slap_op_q_destroy( void *key, void *data )
{
Operation *op, *op2;
for ( op = data; op; op = op2 ) {
op2 = LDAP_STAILQ_NEXT( op, o_next );
ber_memfree_x( op, NULL );
}
}
1998-08-09 08:43:13 +08:00
void
slap_op_groups_free( Operation *op )
{
GroupAssertion *g, *n;
for ( g = op->o_groups; g; g = n ) {
n = g->ga_next;
slap_sl_free( g, op->o_tmpmemctx );
}
op->o_groups = NULL;
}
1998-08-09 08:43:13 +08:00
void
slap_op_free( Operation *op, void *ctx )
1998-08-09 08:43:13 +08:00
{
OperationBuffer *opbuf;
assert( LDAP_STAILQ_NEXT(op, o_next) == NULL );
if ( op->o_ber != NULL ) {
1998-08-09 08:43:13 +08:00
ber_free( op->o_ber, 1 );
}
if ( !BER_BVISNULL( &op->o_dn ) ) {
ch_free( op->o_dn.bv_val );
2002-08-07 14:37:11 +08:00
}
if ( !BER_BVISNULL( &op->o_ndn ) ) {
ch_free( op->o_ndn.bv_val );
2002-08-07 14:37:11 +08:00
}
if ( !BER_BVISNULL( &op->o_authmech ) ) {
ch_free( op->o_authmech.bv_val );
2002-08-07 14:37:11 +08:00
}
1999-07-06 07:01:17 +08:00
if ( op->o_ctrls != NULL ) {
slap_free_ctrls( op, op->o_ctrls );
1999-07-06 07:01:17 +08:00
}
#ifdef LDAP_CONNECTIONLESS
if ( op->o_res_ber != NULL ) {
ber_free( op->o_res_ber, 1 );
}
#endif
if ( op->o_groups ) {
slap_op_groups_free( op );
}
#if defined( LDAP_SLAPI )
if ( slapi_plugins_used ) {
slapi_int_free_object_extensions( SLAPI_X_EXT_OPERATION, op );
}
#endif /* defined( LDAP_SLAPI ) */
opbuf = (OperationBuffer *) op;
memset( opbuf, 0, sizeof(*opbuf) );
op->o_hdr = &opbuf->ob_hdr;
op->o_controls = opbuf->ob_controls;
if ( ctx ) {
Operation *op2;
void *otmp = NULL;
ldap_pvt_thread_pool_getkey( ctx, (void *)slap_op_free, &otmp, NULL );
op2 = otmp;
LDAP_STAILQ_NEXT( op, o_next ) = op2;
ldap_pvt_thread_pool_setkey( ctx, (void *)slap_op_free,
(void *)op, slap_op_q_destroy, NULL, NULL );
} else {
ber_memfree_x( op, NULL );
}
1998-08-09 08:43:13 +08:00
}
2005-10-13 19:58:44 +08:00
void
slap_op_time(time_t *t, int *nop)
{
*t = slap_get_time();
ldap_pvt_thread_mutex_lock( &slap_op_mutex );
if ( *t == last_time ) {
*nop = ++last_incr;
} else {
last_time = *t;
last_incr = 0;
*nop = 0;
}
ldap_pvt_thread_mutex_unlock( &slap_op_mutex );
}
1998-08-09 08:43:13 +08:00
Operation *
slap_op_alloc(
1998-08-09 08:43:13 +08:00
BerElement *ber,
ber_int_t msgid,
ber_tag_t tag,
ber_int_t id,
void *ctx )
1998-08-09 08:43:13 +08:00
{
Operation *op = NULL;
if ( ctx ) {
void *otmp = NULL;
ldap_pvt_thread_pool_getkey( ctx, (void *)slap_op_free, &otmp, NULL );
if ( otmp ) {
op = otmp;
otmp = LDAP_STAILQ_NEXT( op, o_next );
ldap_pvt_thread_pool_setkey( ctx, (void *)slap_op_free,
otmp, slap_op_q_destroy, NULL, NULL );
}
}
if (!op) {
op = (Operation *) ch_calloc( 1, sizeof(OperationBuffer) );
op->o_hdr = &((OperationBuffer *) op)->ob_hdr;
op->o_controls = ((OperationBuffer *) op)->ob_controls;
}
op->o_ber = ber;
op->o_msgid = msgid;
op->o_tag = tag;
2005-10-13 19:58:44 +08:00
slap_op_time( &op->o_time, &op->o_tincr );
op->o_opid = id;
op->o_res_ber = NULL;
1998-08-09 08:43:13 +08:00
#if defined( LDAP_SLAPI )
if ( slapi_plugins_used ) {
slapi_int_create_object_extensions( SLAPI_X_EXT_OPERATION, op );
}
#endif /* defined( LDAP_SLAPI ) */
return( op );
1998-08-09 08:43:13 +08:00
}
2006-09-04 15:17:34 +08:00
slap_op_t
slap_req2op( ber_tag_t tag )
{
switch ( tag ) {
case LDAP_REQ_BIND:
return SLAP_OP_BIND;
case LDAP_REQ_UNBIND:
return SLAP_OP_UNBIND;
case LDAP_REQ_ADD:
return SLAP_OP_ADD;
case LDAP_REQ_DELETE:
return SLAP_OP_DELETE;
case LDAP_REQ_MODRDN:
return SLAP_OP_MODRDN;
case LDAP_REQ_MODIFY:
return SLAP_OP_MODIFY;
case LDAP_REQ_COMPARE:
return SLAP_OP_COMPARE;
case LDAP_REQ_SEARCH:
return SLAP_OP_SEARCH;
case LDAP_REQ_ABANDON:
return SLAP_OP_ABANDON;
case LDAP_REQ_EXTENDED:
return SLAP_OP_EXTENDED;
}
return SLAP_OP_LAST;
}