Back to index

openldap  2.4.31
Functions | Variables
operation.c File Reference
#include "portable.h"
#include <stdio.h>
#include <ac/string.h>
#include <ac/socket.h>
#include "slap.h"

Go to the source code of this file.

Functions

void slap_op_init (void)
void slap_op_destroy (void)
static void slap_op_q_destroy (void *key, void *data)
void slap_op_groups_free (Operation *op)
void slap_op_free (Operation *op, void *ctx)
void slap_op_time (time_t *t, int *nop)
Operationslap_op_alloc (BerElement *ber, ber_int_t msgid, ber_tag_t tag, ber_int_t id, void *ctx)
slap_op_t slap_req2op (ber_tag_t tag)

Variables

static ldap_pvt_thread_mutex_t slap_op_mutex
static time_t last_time
static int last_incr

Function Documentation

Operation* slap_op_alloc ( BerElement *  ber,
ber_int_t  msgid,
ber_tag_t  tag,
ber_int_t  id,
void ctx 
)

Definition at line 175 of file operation.c.

{
       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 );
                     op->o_abandon = 0;
                     op->o_cancel = 0;
              }
       }
       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;

       slap_op_time( &op->o_time, &op->o_tincr );
       op->o_opid = id;

#if defined( LDAP_SLAPI )
       if ( slapi_plugins_used ) {
              slapi_int_create_object_extensions( SLAPI_X_EXT_OPERATION, op );
       }
#endif /* defined( LDAP_SLAPI ) */

       return( op );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 49 of file operation.c.

{
       ldap_pvt_thread_mutex_destroy( &slap_op_mutex );
}

Here is the caller graph for this function:

void slap_op_free ( Operation op,
void ctx 
)

Definition at line 76 of file operation.c.

{
       OperationBuffer *opbuf;

       assert( LDAP_STAILQ_NEXT(op, o_next) == NULL );

       /* paranoia */
       op->o_abandon = 1;

       if ( op->o_ber != NULL ) {
              ber_free( op->o_ber, 1 );
       }
       if ( !BER_BVISNULL( &op->o_dn ) ) {
              ch_free( op->o_dn.bv_val );
       }
       if ( !BER_BVISNULL( &op->o_ndn ) ) {
              ch_free( op->o_ndn.bv_val );
       }
       if ( !BER_BVISNULL( &op->o_authmech ) ) {
              ch_free( op->o_authmech.bv_val );
       }
       if ( op->o_ctrls != NULL ) {
              slap_free_ctrls( op, op->o_ctrls );
       }

#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 ) */

       if ( !BER_BVISNULL( &op->o_csn ) ) {
              op->o_tmpfree( op->o_csn.bv_val, op->o_tmpmemctx );
       }

       if ( op->o_pagedresults_state != NULL ) {
              op->o_tmpfree( op->o_pagedresults_state, op->o_tmpmemctx );
       }

       /* Selectively zero out the struct. Ignore fields that will
        * get explicitly initialized later anyway. Keep o_abandon intact.
        */
       opbuf = (OperationBuffer *) op;
       op->o_bd = NULL;
       BER_BVZERO( &op->o_req_dn );
       BER_BVZERO( &op->o_req_ndn );
       memset( op->o_hdr, 0, sizeof( *op->o_hdr ));
       memset( &op->o_request, 0, sizeof( op->o_request ));
       memset( &op->o_do_not_cache, 0, sizeof( Operation ) - offsetof( Operation, o_do_not_cache ));
       memset( opbuf->ob_controls, 0, sizeof( opbuf->ob_controls ));
       op->o_controls = opbuf->ob_controls;

       if ( ctx ) {
              Operation *op2 = NULL;
              ldap_pvt_thread_pool_setkey( ctx, (void *)slap_op_free,
                     op, slap_op_q_destroy, (void **)&op2, NULL );
              LDAP_STAILQ_NEXT( op, o_next ) = op2;
              if ( op2 ) {
                     op->o_tincr = op2->o_tincr + 1;
                     /* No more than 10 ops on per-thread free list */
                     if ( op->o_tincr > 10 ) {
                            ldap_pvt_thread_pool_setkey( ctx, (void *)slap_op_free,
                                   op2, slap_op_q_destroy, NULL, NULL );
                            ber_memfree_x( op, NULL );
                     }
              } else {
                     op->o_tincr = 1;
              }
       } else {
              ber_memfree_x( op, NULL );
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 65 of file operation.c.

{
       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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 44 of file operation.c.

{
       ldap_pvt_thread_mutex_init( &slap_op_mutex );
}

Here is the caller graph for this function:

static void slap_op_q_destroy ( void key,
void data 
) [static]

Definition at line 55 of file operation.c.

{
       Operation *op, *op2;
       for ( op = data; op; op = op2 ) {
              op2 = LDAP_STAILQ_NEXT( op, o_next );
              ber_memfree_x( op, NULL );
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void slap_op_time ( time_t *  t,
int nop 
)

Definition at line 160 of file operation.c.

{
       ldap_pvt_thread_mutex_lock( &slap_op_mutex );
       *t = slap_get_time();
       if ( *t == last_time ) {
              *nop = ++last_incr;
       } else {
              last_time = *t;
              last_incr = 0;
              *nop = 0;
       }
       ldap_pvt_thread_mutex_unlock( &slap_op_mutex );
}

Here is the caller graph for this function:

slap_op_t slap_req2op ( ber_tag_t  tag)

Definition at line 219 of file operation.c.

Here is the caller graph for this function:


Variable Documentation

int last_incr [static]

Definition at line 42 of file operation.c.

time_t last_time [static]

Definition at line 41 of file operation.c.

Definition at line 40 of file operation.c.