]> git.sur5r.net Git - openldap/blob - servers/slapd/operation.c
make sure o_csn is freed
[openldap] / servers / slapd / operation.c
1 /* operation.c - routines to deal with pending ldap operations */
2 /* $OpenLDAP$ */
3 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
4  *
5  * Copyright 1998-2008 The OpenLDAP Foundation.
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted only as authorized by the OpenLDAP
10  * Public License.
11  *
12  * A copy of this license is available in the file LICENSE in the
13  * top-level directory of the distribution or, alternatively, at
14  * <http://www.OpenLDAP.org/license.html>.
15  */
16 /* Portions Copyright (c) 1995 Regents of the University of Michigan.
17  * All rights reserved.
18  *
19  * Redistribution and use in source and binary forms are permitted
20  * provided that this notice is preserved and that due credit is given
21  * to the University of Michigan at Ann Arbor. The name of the University
22  * may not be used to endorse or promote products derived from this
23  * software without specific prior written permission. This software
24  * is provided ``as is'' without express or implied warranty.
25  */
26
27 #include "portable.h"
28
29 #include <stdio.h>
30
31 #include <ac/string.h>
32 #include <ac/socket.h>
33
34 #include "slap.h"
35
36 #ifdef LDAP_SLAPI
37 #include "slapi/slapi.h"
38 #endif
39
40 static ldap_pvt_thread_mutex_t  slap_op_mutex;
41 static time_t last_time;
42 static int last_incr;
43
44 void slap_op_init(void)
45 {
46         ldap_pvt_thread_mutex_init( &slap_op_mutex );
47 }
48
49 void slap_op_destroy(void)
50 {
51         ldap_pvt_thread_mutex_destroy( &slap_op_mutex );
52 }
53
54 static void
55 slap_op_q_destroy( void *key, void *data )
56 {
57         Operation *op, *op2;
58         for ( op = data; op; op = op2 ) {
59                 op2 = LDAP_STAILQ_NEXT( op, o_next );
60                 ber_memfree_x( op, NULL );
61         }
62 }
63
64 void
65 slap_op_groups_free( Operation *op )
66 {
67         GroupAssertion *g, *n;
68         for ( g = op->o_groups; g; g = n ) {
69                 n = g->ga_next;
70                 slap_sl_free( g, op->o_tmpmemctx );
71         }
72         op->o_groups = NULL;
73 }
74
75 void
76 slap_op_free( Operation *op, void *ctx )
77 {
78         OperationBuffer *opbuf;
79
80         assert( LDAP_STAILQ_NEXT(op, o_next) == NULL );
81
82         if ( op->o_ber != NULL ) {
83                 ber_free( op->o_ber, 1 );
84         }
85         if ( !BER_BVISNULL( &op->o_dn ) ) {
86                 ch_free( op->o_dn.bv_val );
87         }
88         if ( !BER_BVISNULL( &op->o_ndn ) ) {
89                 ch_free( op->o_ndn.bv_val );
90         }
91         if ( !BER_BVISNULL( &op->o_authmech ) ) {
92                 ch_free( op->o_authmech.bv_val );
93         }
94         if ( op->o_ctrls != NULL ) {
95                 slap_free_ctrls( op, op->o_ctrls );
96         }
97
98 #ifdef LDAP_CONNECTIONLESS
99         if ( op->o_res_ber != NULL ) {
100                 ber_free( op->o_res_ber, 1 );
101         }
102 #endif
103
104         if ( op->o_groups ) {
105                 slap_op_groups_free( op );
106         }
107
108 #if defined( LDAP_SLAPI )
109         if ( slapi_plugins_used ) {
110                 slapi_int_free_object_extensions( SLAPI_X_EXT_OPERATION, op );
111         }
112 #endif /* defined( LDAP_SLAPI ) */
113
114         if ( !BER_BVISNULL( &op->o_csn ) ) {
115                 op->o_tmpfree( op->o_csn.bv_val, op->o_tmpmemctx );
116                 BER_BVZERO( &op->o_csn );
117         }
118
119         opbuf = (OperationBuffer *) op;
120         memset( opbuf, 0, sizeof(*opbuf) );
121         op->o_hdr = &opbuf->ob_hdr;
122         op->o_controls = opbuf->ob_controls;
123
124         if ( ctx ) {
125                 void *op2 = NULL;
126                 ldap_pvt_thread_pool_setkey( ctx, (void *)slap_op_free,
127                         op, slap_op_q_destroy, &op2, NULL );
128                 LDAP_STAILQ_NEXT( op, o_next ) = op2;
129         } else {
130                 ber_memfree_x( op, NULL );
131         }
132 }
133
134 void
135 slap_op_time(time_t *t, int *nop)
136 {
137         ldap_pvt_thread_mutex_lock( &slap_op_mutex );
138         *t = slap_get_time();
139         if ( *t == last_time ) {
140                 *nop = ++last_incr;
141         } else {
142                 last_time = *t;
143                 last_incr = 0;
144                 *nop = 0;
145         }
146         ldap_pvt_thread_mutex_unlock( &slap_op_mutex );
147 }
148
149 Operation *
150 slap_op_alloc(
151     BerElement          *ber,
152     ber_int_t   msgid,
153     ber_tag_t   tag,
154     ber_int_t   id,
155         void *ctx )
156 {
157         Operation       *op = NULL;
158
159         if ( ctx ) {
160                 void *otmp = NULL;
161                 ldap_pvt_thread_pool_getkey( ctx, (void *)slap_op_free, &otmp, NULL );
162                 if ( otmp ) {
163                         op = otmp;
164                         otmp = LDAP_STAILQ_NEXT( op, o_next );
165                         ldap_pvt_thread_pool_setkey( ctx, (void *)slap_op_free,
166                                 otmp, slap_op_q_destroy, NULL, NULL );
167                 }
168         }
169         if (!op) {
170                 op = (Operation *) ch_calloc( 1, sizeof(OperationBuffer) );
171                 op->o_hdr = &((OperationBuffer *) op)->ob_hdr;
172                 op->o_controls = ((OperationBuffer *) op)->ob_controls;
173         }
174
175         op->o_ber = ber;
176         op->o_msgid = msgid;
177         op->o_tag = tag;
178
179         slap_op_time( &op->o_time, &op->o_tincr );
180         op->o_opid = id;
181         op->o_res_ber = NULL;
182
183 #if defined( LDAP_SLAPI )
184         if ( slapi_plugins_used ) {
185                 slapi_int_create_object_extensions( SLAPI_X_EXT_OPERATION, op );
186         }
187 #endif /* defined( LDAP_SLAPI ) */
188
189         return( op );
190 }
191
192 slap_op_t
193 slap_req2op( ber_tag_t tag )
194 {
195         switch ( tag ) {
196         case LDAP_REQ_BIND:
197                 return SLAP_OP_BIND;
198         case LDAP_REQ_UNBIND:
199                 return SLAP_OP_UNBIND;
200         case LDAP_REQ_ADD:
201                 return SLAP_OP_ADD;
202         case LDAP_REQ_DELETE:
203                 return SLAP_OP_DELETE;
204         case LDAP_REQ_MODRDN:
205                 return SLAP_OP_MODRDN;
206         case LDAP_REQ_MODIFY:
207                 return SLAP_OP_MODIFY;
208         case LDAP_REQ_COMPARE:
209                 return SLAP_OP_COMPARE;
210         case LDAP_REQ_SEARCH:
211                 return SLAP_OP_SEARCH;
212         case LDAP_REQ_ABANDON:
213                 return SLAP_OP_ABANDON;
214         case LDAP_REQ_EXTENDED:
215                 return SLAP_OP_EXTENDED;
216         }
217
218         return SLAP_OP_LAST;
219 }