]> git.sur5r.net Git - openldap/blob - libraries/libldap/controls.c
Add prototypes for grouping functions
[openldap] / libraries / libldap / controls.c
1 /* $OpenLDAP$ */
2 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
3  *
4  * Copyright 1998-2004 The OpenLDAP Foundation.
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted only as authorized by the OpenLDAP
9  * Public License.
10  *
11  * A copy of this license is available in the file LICENSE in the
12  * top-level directory of the distribution or, alternatively, at
13  * <http://www.OpenLDAP.org/license.html>.
14  */
15 /* This notice applies to changes, created by or for Novell, Inc.,
16  * to preexisting works for which notices appear elsewhere in this file.
17  *
18  * Copyright (C) 1999, 2000 Novell, Inc. All Rights Reserved.
19  *
20  * THIS WORK IS SUBJECT TO U.S. AND INTERNATIONAL COPYRIGHT LAWS AND TREATIES.
21  * USE, MODIFICATION, AND REDISTRIBUTION OF THIS WORK IS SUBJECT TO VERSION
22  * 2.0.1 OF THE OPENLDAP PUBLIC LICENSE, A COPY OF WHICH IS AVAILABLE AT
23  * HTTP://WWW.OPENLDAP.ORG/LICENSE.HTML OR IN THE FILE "LICENSE" IN THE
24  * TOP-LEVEL DIRECTORY OF THE DISTRIBUTION. ANY USE OR EXPLOITATION OF THIS
25  * WORK OTHER THAN AS AUTHORIZED IN VERSION 2.0.1 OF THE OPENLDAP PUBLIC
26  * LICENSE, OR OTHER PRIOR WRITTEN CONSENT FROM NOVELL, COULD SUBJECT THE
27  * PERPETRATOR TO CRIMINAL AND CIVIL LIABILITY. 
28  *---
29  * Note: A verbatim copy of version 2.0.1 of the OpenLDAP Public License
30  * can be found in the file "build/LICENSE-2.0.1" in this distribution
31  * of OpenLDAP Software.
32  */
33 /* Portions Copyright (C) The Internet Society (1997)
34  * ASN.1 fragments are from RFC 2251; see RFC for full legal notices.
35  */
36
37 /* LDAPv3 Controls (RFC2251)
38  *
39  *      Controls ::= SEQUENCE OF Control  
40  *
41  *      Control ::= SEQUENCE { 
42  *              controlType             LDAPOID,
43  *              criticality             BOOLEAN DEFAULT FALSE,
44  *              controlValue    OCTET STRING OPTIONAL
45  *      }
46  */
47
48 #include "portable.h"
49
50 #include <ac/stdlib.h>
51
52 #include <ac/time.h>
53 #include <ac/string.h>
54
55 #include "ldap-int.h"
56
57
58 /*
59  * ldap_int_put_controls
60  */
61
62 int
63 ldap_int_put_controls(
64         LDAP *ld,
65         LDAPControl *const *ctrls,
66         BerElement *ber )
67 {
68         LDAPControl *const *c;
69
70         assert( ld != NULL );
71         assert( LDAP_VALID(ld) );
72         assert( ber != NULL );
73
74         if( ctrls == NULL ) {
75                 /* use default server controls */
76                 ctrls = ld->ld_sctrls;
77         }
78
79         if( ctrls == NULL || *ctrls == NULL ) {
80                 return LDAP_SUCCESS;
81         }
82
83         if ( ld->ld_version < LDAP_VERSION3 ) {
84                 /* LDAPv2 doesn't support controls,
85                  * error if any control is critical
86                  */
87                 for( c = ctrls ; *c != NULL; c++ ) {
88                         if( (*c)->ldctl_iscritical ) {
89                                 ld->ld_errno = LDAP_NOT_SUPPORTED;
90                                 return ld->ld_errno;
91                         }
92                 }
93
94                 return LDAP_SUCCESS;
95         }
96
97         /* Controls are encoded as a sequence of sequences */
98         if( ber_printf( ber, "t{"/*}*/, LDAP_TAG_CONTROLS ) == -1 ) {
99                 ld->ld_errno = LDAP_ENCODING_ERROR;
100                 return ld->ld_errno;
101         }
102
103         for( c = ctrls ; *c != NULL; c++ ) {
104                 if ( ber_printf( ber, "{s" /*}*/,
105                         (*c)->ldctl_oid ) == -1 )
106                 {
107                         ld->ld_errno = LDAP_ENCODING_ERROR;
108                         return ld->ld_errno;
109                 }
110
111                 if( (*c)->ldctl_iscritical /* only if true */
112                         &&  ( ber_printf( ber, "b",
113                                 (ber_int_t) (*c)->ldctl_iscritical ) == -1 ) )
114                 {
115                         ld->ld_errno = LDAP_ENCODING_ERROR;
116                         return ld->ld_errno;
117                 }
118
119                 if( (*c)->ldctl_value.bv_val != NULL /* only if we have a value */
120                         &&  ( ber_printf( ber, "O",
121                                 &((*c)->ldctl_value) ) == -1 ) )
122                 {
123                         ld->ld_errno = LDAP_ENCODING_ERROR;
124                         return ld->ld_errno;
125                 }
126
127
128                 if( ber_printf( ber, /*{*/"N}" ) == -1 ) {
129                         ld->ld_errno = LDAP_ENCODING_ERROR;
130                         return ld->ld_errno;
131                 }
132         }
133
134
135         if( ber_printf( ber, /*{*/ "}" ) == -1 ) {
136                 ld->ld_errno = LDAP_ENCODING_ERROR;
137                 return ld->ld_errno;
138         }
139
140         return LDAP_SUCCESS;
141 }
142
143 int ldap_pvt_get_controls(
144         BerElement *ber,
145         LDAPControl ***ctrls )
146 {
147         int nctrls;
148         ber_tag_t tag;
149         ber_len_t len;
150         char *opaque;
151
152         assert( ber != NULL );
153
154         if( ctrls == NULL ) {
155                 return LDAP_SUCCESS;
156         }
157         *ctrls = NULL;
158
159         len = ber_pvt_ber_remaining( ber );
160
161         if( len == 0) {
162                 /* no controls */
163                 return LDAP_SUCCESS;
164         }
165
166         if(( tag = ber_peek_tag( ber, &len )) != LDAP_TAG_CONTROLS ) {
167                 if( tag == LBER_ERROR ) {
168                         /* decoding error */
169                         return LDAP_DECODING_ERROR;
170                 }
171
172                 /* ignore unexpected input */
173                 return LDAP_SUCCESS;
174         }
175
176         /* set through each element */
177         nctrls = 0;
178         *ctrls = LDAP_MALLOC( 1 * sizeof(LDAPControl *) );
179
180         if( *ctrls == NULL ) {
181                 return LDAP_NO_MEMORY;
182         }
183
184         *ctrls[nctrls] = NULL;
185
186         for( tag = ber_first_element( ber, &len, &opaque );
187                 tag != LBER_ERROR;
188                 tag = ber_next_element( ber, &len, opaque ) )
189         {
190                 LDAPControl *tctrl;
191                 LDAPControl **tctrls;
192
193                 tctrl = LDAP_CALLOC( 1, sizeof(LDAPControl) );
194
195                 /* allocate pointer space for current controls (nctrls)
196                  * + this control + extra NULL
197                  */
198                 tctrls = (tctrl == NULL) ? NULL :
199                         LDAP_REALLOC(*ctrls, (nctrls+2) * sizeof(LDAPControl *));
200
201                 if( tctrls == NULL ) {
202                         /* one of the above allocation failed */
203
204                         if( tctrl != NULL ) {
205                                 LDAP_FREE( tctrl );
206                         }
207
208                         ldap_controls_free(*ctrls);
209                         *ctrls = NULL;
210
211                         return LDAP_NO_MEMORY;
212                 }
213
214
215                 tctrls[nctrls++] = tctrl;
216                 tctrls[nctrls] = NULL;
217
218                 tag = ber_scanf( ber, "{a" /*}*/, &tctrl->ldctl_oid );
219
220                 if( tag == LBER_ERROR ) {
221                         *ctrls = NULL;
222                         ldap_controls_free( tctrls );
223                         return LDAP_DECODING_ERROR;
224                 }
225
226                 tag = ber_peek_tag( ber, &len );
227
228                 if( tag == LBER_BOOLEAN ) {
229                         ber_int_t crit;
230                         tag = ber_scanf( ber, "b", &crit );
231                         tctrl->ldctl_iscritical = crit ? (char) 0 : (char) ~0;
232                         tag = ber_peek_tag( ber, &len );
233                 }
234
235                 if( tag == LBER_OCTETSTRING ) {
236                         tag = ber_scanf( ber, "o", &tctrl->ldctl_value );
237                 } else {
238                         tctrl->ldctl_value.bv_val = NULL;
239                 }
240
241                 *ctrls = tctrls;
242         }
243                 
244         return LDAP_SUCCESS;
245 }
246
247 /*
248  * Free a LDAPControl
249  */
250 void
251 ldap_control_free( LDAPControl *c )
252 {
253 #ifdef LDAP_MEMORY_DEBUG
254         assert( c != NULL );
255 #endif
256
257         if ( c != NULL ) {
258                 if( c->ldctl_oid != NULL) {
259                         LDAP_FREE( c->ldctl_oid );
260                 }
261
262                 if( c->ldctl_value.bv_val != NULL ) {
263                         LDAP_FREE( c->ldctl_value.bv_val );
264                 }
265
266                 LDAP_FREE( c );
267         }
268 }
269
270 /*
271  * Free an array of LDAPControl's
272  */
273 void
274 ldap_controls_free( LDAPControl **controls )
275 {
276 #ifdef LDAP_MEMORY_DEBUG
277         assert( controls != NULL );
278 #endif
279
280         if ( controls != NULL ) {
281                 int i;
282
283                 for( i=0; controls[i] != NULL; i++) {
284                         ldap_control_free( controls[i] );
285                 }
286
287                 LDAP_FREE( controls );
288         }
289 }
290
291 /*
292  * Duplicate an array of LDAPControl
293  */
294 LDAPControl **
295 ldap_controls_dup( LDAPControl *const *controls )
296 {
297         LDAPControl **new;
298         int i;
299
300         if ( controls == NULL ) {
301                 return NULL;
302         }
303
304         /* count the controls */
305         for(i=0; controls[i] != NULL; i++) /* empty */ ;
306
307         if( i < 1 ) {
308                 /* no controls to duplicate */
309                 return NULL;
310         }
311
312         new = (LDAPControl **) LDAP_MALLOC( (i+1) * sizeof(LDAPControl *) );
313
314         if( new == NULL ) {
315                 /* memory allocation failure */
316                 return NULL;
317         }
318
319         /* duplicate the controls */
320         for(i=0; controls[i] != NULL; i++) {
321                 new[i] = ldap_control_dup( controls[i] );
322
323                 if( new[i] == NULL ) {
324                         ldap_controls_free( new );
325                         return NULL;
326                 }
327         }
328
329         new[i] = NULL;
330
331         return new;
332 }
333
334 /*
335  * Duplicate a LDAPControl
336  */
337 LDAPControl *
338 ldap_control_dup( const LDAPControl *c )
339 {
340         LDAPControl *new;
341
342         if ( c == NULL ) {
343                 return NULL;
344         }
345
346         new = (LDAPControl *) LDAP_MALLOC( sizeof(LDAPControl) );
347
348         if( new == NULL ) {
349                 return NULL;
350         }
351
352         if( c->ldctl_oid != NULL ) {
353                 new->ldctl_oid = LDAP_STRDUP( c->ldctl_oid );
354
355                 if(new->ldctl_oid == NULL) {
356                         LDAP_FREE( new );
357                         return NULL;
358                 }
359
360         } else {
361                 new->ldctl_oid = NULL;
362         }
363
364         if( c->ldctl_value.bv_val != NULL ) {
365                 new->ldctl_value.bv_val =
366                         (char *) LDAP_MALLOC( c->ldctl_value.bv_len + 1 );
367
368                 if(new->ldctl_value.bv_val == NULL) {
369                         if(new->ldctl_oid != NULL) {
370                                 LDAP_FREE( new->ldctl_oid );
371                         }
372                         LDAP_FREE( new );
373                         return NULL;
374                 }
375                 
376                 new->ldctl_value.bv_len = c->ldctl_value.bv_len;
377
378                 AC_MEMCPY( new->ldctl_value.bv_val, c->ldctl_value.bv_val, 
379                         c->ldctl_value.bv_len );
380
381                 new->ldctl_value.bv_val[new->ldctl_value.bv_len] = '\0';
382
383         } else {
384                 new->ldctl_value.bv_len = 0;
385                 new->ldctl_value.bv_val = NULL;
386         }
387
388         new->ldctl_iscritical = c->ldctl_iscritical;
389         return new;
390 }
391
392
393 LDAPControl *
394 ldap_find_control(
395         LDAP_CONST char *oid,
396         LDAPControl **ctrls )
397 {
398         if( ctrls == NULL || *ctrls == NULL ) {
399                 return NULL;
400         }
401
402         for( ; *ctrls != NULL; ctrls++ ) {
403                 if( strcmp( (*ctrls)->ldctl_oid, oid ) == 0 ) {
404                         return *ctrls;
405                 }
406         }
407
408         return NULL;
409 }
410
411 /*
412    ldap_create_control
413    
414    Internal function to create an LDAP control from the encoded BerElement.
415
416    requestOID  (IN) The OID to use in creating the control.
417    
418    ber         (IN) The encoded BerElement to use in creating the control.
419    
420    iscritical  (IN) 0 - Indicates the control is not critical to the operation.
421                                         non-zero - The control is critical to the operation.
422                                   
423    ctrlp      (OUT) Returns a pointer to the LDAPControl created.  This control
424                                         SHOULD be freed by calling ldap_control_free() when done.
425 ---*/
426
427 int
428 ldap_create_control(
429         LDAP_CONST char *requestOID,
430         BerElement *ber,
431         int iscritical,
432         LDAPControl **ctrlp )
433 {
434         LDAPControl *ctrl;
435
436         assert( requestOID != NULL );
437         assert( ber != NULL );
438         assert( ctrlp != NULL );
439
440         ctrl = (LDAPControl *) LDAP_MALLOC( sizeof(LDAPControl) );
441         if ( ctrl == NULL ) {
442                 return LDAP_NO_MEMORY;
443         }
444
445         if ( ber_flatten2( ber, &ctrl->ldctl_value, 1 ) == -1 ) {
446                 LDAP_FREE( ctrl );
447                 return LDAP_NO_MEMORY;
448         }
449
450         ctrl->ldctl_oid = LDAP_STRDUP( requestOID );
451         ctrl->ldctl_iscritical = iscritical;
452
453         if ( requestOID != NULL && ctrl->ldctl_oid == NULL ) {
454                 ldap_control_free( ctrl );
455                 return LDAP_NO_MEMORY;
456         }
457
458         *ctrlp = ctrl;
459         return LDAP_SUCCESS;
460 }
461
462 /*
463  * check for critical client controls and bitch if present
464  * if we ever support critical controls, we'll have to
465  * find a means for maintaining per API call control
466  * information.
467  */
468 int ldap_int_client_controls( LDAP *ld, LDAPControl **ctrls )
469 {
470         LDAPControl *const *c;
471
472         assert( ld != NULL );
473         assert( LDAP_VALID(ld) );
474
475         if( ctrls == NULL ) {
476                 /* use default server controls */
477                 ctrls = ld->ld_cctrls;
478         }
479
480         if( ctrls == NULL || *ctrls == NULL ) {
481                 return LDAP_SUCCESS;
482         }
483
484         for( c = ctrls ; *c != NULL; c++ ) {
485                 if( (*c)->ldctl_iscritical ) {
486                         ld->ld_errno = LDAP_NOT_SUPPORTED;
487                         return ld->ld_errno;
488                 }
489         }
490
491         return LDAP_SUCCESS;
492 }