X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=libraries%2Flibldap%2Fcontrols.c;h=81ca1c392562502d31232d5a0702fa821c3462f9;hb=02cff39398a62956aa3a86b834fb317415ccc601;hp=3632b8fc0f44513b614556cf61baa091581c9ca9;hpb=d0d80a633a25730356c7834aede8b85a186a409b;p=openldap diff --git a/libraries/libldap/controls.c b/libraries/libldap/controls.c index 3632b8fc0f..81ca1c3925 100644 --- a/libraries/libldap/controls.c +++ b/libraries/libldap/controls.c @@ -1,12 +1,48 @@ /* $OpenLDAP$ */ -/* - * Copyright 1998-1999 The OpenLDAP Foundation, All Rights Reserved. - * COPYING RESTRICTIONS APPLY, see COPYRIGHT file +/* This work is part of OpenLDAP Software . + * + * Copyright 1998-2011 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 + * . */ +/* This notice applies to changes, created by or for Novell, Inc., + * to preexisting works for which notices appear elsewhere in this file. + * + * Copyright (C) 1999, 2000 Novell, Inc. All Rights Reserved. + * + * THIS WORK IS SUBJECT TO U.S. AND INTERNATIONAL COPYRIGHT LAWS AND TREATIES. + * USE, MODIFICATION, AND REDISTRIBUTION OF THIS WORK IS SUBJECT TO VERSION + * 2.0.1 OF THE OPENLDAP PUBLIC LICENSE, A COPY OF WHICH IS AVAILABLE AT + * HTTP://WWW.OPENLDAP.ORG/LICENSE.HTML OR IN THE FILE "LICENSE" IN THE + * TOP-LEVEL DIRECTORY OF THE DISTRIBUTION. ANY USE OR EXPLOITATION OF THIS + * WORK OTHER THAN AS AUTHORIZED IN VERSION 2.0.1 OF THE OPENLDAP PUBLIC + * LICENSE, OR OTHER PRIOR WRITTEN CONSENT FROM NOVELL, COULD SUBJECT THE + * PERPETRATOR TO CRIMINAL AND CIVIL LIABILITY. + *--- + * Note: A verbatim copy of version 2.0.1 of the OpenLDAP Public License + * can be found in the file "build/LICENSE-2.0.1" in this distribution + * of OpenLDAP Software. + */ + +#include "portable.h" + +#include -/* LDAPv3 Controls (RFC2251) +#include +#include + +#include "ldap-int.h" + +/* LDAPv3 Controls (RFC 4511) * - * Controls ::= SEQUENCE OF Control + * Controls ::= SEQUENCE OF control Control * * Control ::= SEQUENCE { * controlType LDAPOID, @@ -15,14 +51,34 @@ * } */ -#include "portable.h" +int +ldap_pvt_put_control( + const LDAPControl *c, + BerElement *ber ) +{ + if ( ber_printf( ber, "{s" /*}*/, c->ldctl_oid ) == -1 ) { + return LDAP_ENCODING_ERROR; + } -#include + if ( c->ldctl_iscritical /* only if true */ + && ( ber_printf( ber, "b", + (ber_int_t) c->ldctl_iscritical ) == -1 ) ) + { + return LDAP_ENCODING_ERROR; + } -#include -#include + if ( !BER_BVISNULL( &c->ldctl_value ) /* only if we have a value */ + && ( ber_printf( ber, "O", &c->ldctl_value ) == -1 ) ) + { + return LDAP_ENCODING_ERROR; + } -#include "ldap-int.h" + if ( ber_printf( ber, /*{*/"N}" ) == -1 ) { + return LDAP_ENCODING_ERROR; + } + + return LDAP_SUCCESS; +} /* @@ -38,6 +94,7 @@ ldap_int_put_controls( LDAPControl *const *c; assert( ld != NULL ); + assert( LDAP_VALID( ld ) ); assert( ber != NULL ); if( ctrls == NULL ) { @@ -70,38 +127,14 @@ ldap_int_put_controls( } for( c = ctrls ; *c != NULL; c++ ) { - if ( ber_printf( ber, "{s" /*}*/, - (*c)->ldctl_oid ) == -1 ) - { - ld->ld_errno = LDAP_ENCODING_ERROR; - return ld->ld_errno; - } - - if( (*c)->ldctl_iscritical /* only if true */ - && ( ber_printf( ber, "b", - (ber_int_t) (*c)->ldctl_iscritical ) == -1 ) ) - { - ld->ld_errno = LDAP_ENCODING_ERROR; - return ld->ld_errno; - } - - if( (*c)->ldctl_value.bv_val != NULL /* only if we have a value */ - && ( ber_printf( ber, "O", - &((*c)->ldctl_value) ) == -1 ) ) - { - ld->ld_errno = LDAP_ENCODING_ERROR; - return ld->ld_errno; - } - - - if( ber_printf( ber, /*{*/"}" ) == -1 ) { - ld->ld_errno = LDAP_ENCODING_ERROR; + ld->ld_errno = ldap_pvt_put_control( *c, ber ); + if ( ld->ld_errno != LDAP_SUCCESS ) { return ld->ld_errno; } } - if( ber_printf( ber, /*{*/"}" ) == -1 ) { + if( ber_printf( ber, /*{*/ "}" ) == -1 ) { ld->ld_errno = LDAP_ENCODING_ERROR; return ld->ld_errno; } @@ -109,7 +142,7 @@ ldap_int_put_controls( return LDAP_SUCCESS; } -int ldap_int_get_controls( +int ldap_pvt_get_controls( BerElement *ber, LDAPControl ***ctrls ) { @@ -125,14 +158,13 @@ int ldap_int_get_controls( } *ctrls = NULL; - len = ber_pvt_ber_remaining(ber); + len = ber_pvt_ber_remaining( ber ); if( len == 0) { /* no controls */ return LDAP_SUCCESS; } - if(( tag = ber_peek_tag( ber, &len )) != LDAP_TAG_CONTROLS ) { if( tag == LBER_ERROR ) { /* decoding error */ @@ -187,31 +219,25 @@ int ldap_int_get_controls( tag = ber_scanf( ber, "{a" /*}*/, &tctrl->ldctl_oid ); - if( tag != LBER_ERROR ) { - tag = ber_peek_tag( ber, &len ); + if( tag == LBER_ERROR ) { + *ctrls = NULL; + ldap_controls_free( tctrls ); + return LDAP_DECODING_ERROR; } + tag = ber_peek_tag( ber, &len ); + if( tag == LBER_BOOLEAN ) { ber_int_t crit; tag = ber_scanf( ber, "b", &crit ); tctrl->ldctl_iscritical = crit ? (char) 0 : (char) ~0; - } - - if( tag != LBER_ERROR ) { tag = ber_peek_tag( ber, &len ); } if( tag == LBER_OCTETSTRING ) { tag = ber_scanf( ber, "o", &tctrl->ldctl_value ); - } else { - tctrl->ldctl_value.bv_val = NULL; - } - - if( tag == LBER_ERROR ) { - *ctrls = NULL; - ldap_controls_free( tctrls ); - return LDAP_DECODING_ERROR; + BER_BVZERO( &tctrl->ldctl_value ); } *ctrls = tctrls; @@ -226,9 +252,7 @@ int ldap_int_get_controls( void ldap_control_free( LDAPControl *c ) { -#ifdef LDAP_MEMORY_DEBUG - assert( c != NULL ); -#endif + LDAP_MEMORY_DEBUG_ASSERT( c != NULL ); if ( c != NULL ) { if( c->ldctl_oid != NULL) { @@ -249,9 +273,7 @@ ldap_control_free( LDAPControl *c ) void ldap_controls_free( LDAPControl **controls ) { -#ifdef LDAP_MEMORY_DEBUG - assert( controls != NULL ); -#endif + LDAP_MEMORY_DEBUG_ASSERT( controls != NULL ); if ( controls != NULL ) { int i; @@ -285,7 +307,7 @@ ldap_controls_dup( LDAPControl *const *controls ) return NULL; } - new = (LDAPControl **) LDAP_MALLOC( i * sizeof(LDAPControl *) ); + new = (LDAPControl **) LDAP_MALLOC( (i+1) * sizeof(LDAPControl *) ); if( new == NULL ) { /* memory allocation failure */ @@ -315,7 +337,7 @@ ldap_control_dup( const LDAPControl *c ) { LDAPControl *new; - if ( c == NULL ) { + if ( c == NULL || c->ldctl_oid == NULL ) { return NULL; } @@ -325,20 +347,16 @@ ldap_control_dup( const LDAPControl *c ) return NULL; } - if( c->ldctl_oid != NULL ) { - new->ldctl_oid = LDAP_STRDUP( c->ldctl_oid ); + new->ldctl_oid = LDAP_STRDUP( c->ldctl_oid ); - if(new->ldctl_oid == NULL) { - LDAP_FREE( new ); - return NULL; - } - - } else { - new->ldctl_oid = NULL; + if(new->ldctl_oid == NULL) { + LDAP_FREE( new ); + return NULL; } - if( c->ldctl_value.bv_len > 0 ) { - new->ldctl_value.bv_val = (char *) LDAP_MALLOC( c->ldctl_value.bv_len ); + if( c->ldctl_value.bv_val != NULL ) { + new->ldctl_value.bv_val = + (char *) LDAP_MALLOC( c->ldctl_value.bv_len + 1 ); if(new->ldctl_value.bv_val == NULL) { if(new->ldctl_oid != NULL) { @@ -348,10 +366,12 @@ ldap_control_dup( const LDAPControl *c ) return NULL; } - SAFEMEMCPY( new->ldctl_value.bv_val, c->ldctl_value.bv_val, + new->ldctl_value.bv_len = c->ldctl_value.bv_len; + + AC_MEMCPY( new->ldctl_value.bv_val, c->ldctl_value.bv_val, c->ldctl_value.bv_len ); - new->ldctl_value.bv_len = c->ldctl_value.bv_len; + new->ldctl_value.bv_val[new->ldctl_value.bv_len] = '\0'; } else { new->ldctl_value.bv_len = 0; @@ -361,3 +381,172 @@ ldap_control_dup( const LDAPControl *c ) new->ldctl_iscritical = c->ldctl_iscritical; return new; } + +/* + * Find a LDAPControl - deprecated + */ +LDAPControl * +ldap_find_control( + LDAP_CONST char *oid, + LDAPControl **ctrls ) +{ + if( ctrls == NULL || *ctrls == NULL ) { + return NULL; + } + + for( ; *ctrls != NULL; ctrls++ ) { + if( strcmp( (*ctrls)->ldctl_oid, oid ) == 0 ) { + return *ctrls; + } + } + + return NULL; +} + +/* + * Find a LDAPControl + */ +LDAPControl * +ldap_control_find( + LDAP_CONST char *oid, + LDAPControl **ctrls, + LDAPControl ***nextctrlp ) +{ + if ( oid == NULL || ctrls == NULL || *ctrls == NULL ) { + return NULL; + } + + for( ; *ctrls != NULL; ctrls++ ) { + if( strcmp( (*ctrls)->ldctl_oid, oid ) == 0 ) { + if ( nextctrlp != NULL ) { + *nextctrlp = ctrls + 1; + } + + return *ctrls; + } + } + + if ( nextctrlp != NULL ) { + *nextctrlp = NULL; + } + + return NULL; +} + +/* + * Create a LDAPControl, optionally from ber - deprecated + */ +int +ldap_create_control( + LDAP_CONST char *requestOID, + BerElement *ber, + int iscritical, + LDAPControl **ctrlp ) +{ + LDAPControl *ctrl; + + assert( requestOID != NULL ); + assert( ctrlp != NULL ); + + ctrl = (LDAPControl *) LDAP_MALLOC( sizeof(LDAPControl) ); + if ( ctrl == NULL ) { + return LDAP_NO_MEMORY; + } + + BER_BVZERO(&ctrl->ldctl_value); + if ( ber && ( ber_flatten2( ber, &ctrl->ldctl_value, 1 ) == -1 )) { + LDAP_FREE( ctrl ); + return LDAP_NO_MEMORY; + } + + ctrl->ldctl_oid = LDAP_STRDUP( requestOID ); + ctrl->ldctl_iscritical = iscritical; + + if ( requestOID != NULL && ctrl->ldctl_oid == NULL ) { + ldap_control_free( ctrl ); + return LDAP_NO_MEMORY; + } + + *ctrlp = ctrl; + return LDAP_SUCCESS; +} + +/* + * Create a LDAPControl, optionally from value + */ +int +ldap_control_create( + LDAP_CONST char *requestOID, + int iscritical, + struct berval *value, + int dupval, + LDAPControl **ctrlp ) +{ + LDAPControl *ctrl; + + assert( requestOID != NULL ); + assert( ctrlp != NULL ); + + ctrl = (LDAPControl *) LDAP_CALLOC( sizeof(LDAPControl), 1 ); + if ( ctrl == NULL ) { + return LDAP_NO_MEMORY; + } + + ctrl->ldctl_iscritical = iscritical; + if ( requestOID != NULL ) { + ctrl->ldctl_oid = LDAP_STRDUP( requestOID ); + if ( ctrl->ldctl_oid == NULL ) { + ldap_control_free( ctrl ); + return LDAP_NO_MEMORY; + } + } + + if ( value && !BER_BVISNULL( value ) ) { + if ( dupval ) { + ber_dupbv( &ctrl->ldctl_value, value ); + if ( BER_BVISNULL( &ctrl->ldctl_value ) ) { + ldap_control_free( ctrl ); + return LDAP_NO_MEMORY; + } + + } else { + ctrl->ldctl_value = *value; + } + } + + *ctrlp = ctrl; + + return LDAP_SUCCESS; +} + +/* + * check for critical client controls and bitch if present + * if we ever support critical controls, we'll have to + * find a means for maintaining per API call control + * information. + */ +int ldap_int_client_controls( LDAP *ld, LDAPControl **ctrls ) +{ + LDAPControl *const *c; + + assert( ld != NULL ); + assert( LDAP_VALID( ld ) ); + + if( ctrls == NULL ) { + /* use default server controls */ + ctrls = ld->ld_cctrls; + } + + if( ctrls == NULL || *ctrls == NULL ) { + return LDAP_SUCCESS; + } + + for( c = ctrls ; *c != NULL; c++ ) { + if( (*c)->ldctl_iscritical ) { + ld->ld_errno = LDAP_NOT_SUPPORTED; + return ld->ld_errno; + } + } + + return LDAP_SUCCESS; +}