libs/ldap/libldap/controls.c

   1 /* $OpenLDAP$ */
   2 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
   3  *
   4  * Copyright 1998-2022 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
  34 #include "portable.h"
  35
  36 #include <ac/stdlib.h>
  37
  38 #include <ac/time.h>
  39 #include <ac/string.h>
  40
  41 #include "ldap-int.h"
  42
  43 /* LDAPv3 Controls (RFC 4511)
  44  *
  45  *      Controls ::= SEQUENCE OF control Control
  46  *
  47  *      Control ::= SEQUENCE {
  48  *              controlType             LDAPOID,
  49  *              criticality             BOOLEAN DEFAULT FALSE,
  50  *              controlValue    OCTET STRING OPTIONAL
  51  *      }
  52  */
  53
  54 int
  55 ldap_pvt_put_control(
  56         const LDAPControl *c,
  57         BerElement *ber )
  58 {
  59         if ( ber_printf( ber, "{s" /*}*/, c->ldctl_oid ) == -1 ) {
  60                 return LDAP_ENCODING_ERROR;
  61         }
  62
  63         if ( c->ldctl_iscritical /* only if true */
  64                 &&  ( ber_printf( ber, "b",
  65                         (ber_int_t) c->ldctl_iscritical ) == -1 ) )
  66         {
  67                 return LDAP_ENCODING_ERROR;
  68         }
  69
  70         if ( !BER_BVISNULL( &c->ldctl_value ) /* only if we have a value */
  71                 &&  ( ber_printf( ber, "O", &c->ldctl_value ) == -1 ) )
  72         {
  73                 return LDAP_ENCODING_ERROR;
  74         }
  75
  76         if ( ber_printf( ber, /*{*/"N}" ) == -1 ) {
  77                 return LDAP_ENCODING_ERROR;
  78         }
  79
  80         return LDAP_SUCCESS;
  81 }
  82
  83
  84 /*
  85  * ldap_int_put_controls
  86  */
  87
  88 int
  89 ldap_int_put_controls(
  90         LDAP *ld,
  91         LDAPControl *const *ctrls,
  92         BerElement *ber )
  93 {
  94         LDAPControl *const *c;
  95
  96         assert( ld != NULL );
  97         assert( LDAP_VALID( ld ) );
  98         assert( ber != NULL );
  99
 100         if( ctrls == NULL ) {
 101                 /* use default server controls */
 102                 ctrls = ld->ld_sctrls;
 103         }
 104
 105         if( ctrls == NULL || *ctrls == NULL ) {
 106                 return LDAP_SUCCESS;
 107         }
 108
 109         if ( ld->ld_version < LDAP_VERSION3 ) {
 110                 /* LDAPv2 doesn't support controls,
 111                  * error if any control is critical
 112                  */
 113                 for( c = ctrls ; *c != NULL; c++ ) {
 114                         if( (*c)->ldctl_iscritical ) {
 115                                 ld->ld_errno = LDAP_NOT_SUPPORTED;
 116                                 return ld->ld_errno;
 117                         }
 118                 }
 119
 120                 return LDAP_SUCCESS;
 121         }
 122
 123         /* Controls are encoded as a sequence of sequences */
 124         if( ber_printf( ber, "t{"/*}*/, LDAP_TAG_CONTROLS ) == -1 ) {
 125                 ld->ld_errno = LDAP_ENCODING_ERROR;
 126                 return ld->ld_errno;
 127         }
 128
 129         for( c = ctrls ; *c != NULL; c++ ) {
 130                 ld->ld_errno = ldap_pvt_put_control( *c, ber );
 131                 if ( ld->ld_errno != LDAP_SUCCESS ) {
 132                         return ld->ld_errno;
 133                 }
 134         }
 135
 136
 137         if( ber_printf( ber, /*{*/ "}" ) == -1 ) {
 138                 ld->ld_errno = LDAP_ENCODING_ERROR;
 139                 return ld->ld_errno;
 140         }
 141
 142         return LDAP_SUCCESS;
 143 }
 144
 145 int ldap_pvt_get_controls(
 146         BerElement *ber,
 147         LDAPControl ***ctrls )
 148 {
 149         int nctrls;
 150         ber_tag_t tag;
 151         ber_len_t len;
 152         char *opaque;
 153
 154         assert( ber != NULL );
 155
 156         if( ctrls == NULL ) {
 157                 return LDAP_SUCCESS;
 158         }
 159         *ctrls = NULL;
 160
 161         len = ber_pvt_ber_remaining( ber );
 162
 163         if( len == 0) {
 164                 /* no controls */
 165                 return LDAP_SUCCESS;
 166         }
 167
 168         if(( tag = ber_peek_tag( ber, &len )) != LDAP_TAG_CONTROLS ) {
 169                 if( tag == LBER_ERROR ) {
 170                         /* decoding error */
 171                         return LDAP_DECODING_ERROR;
 172                 }
 173
 174                 /* ignore unexpected input */
 175                 return LDAP_SUCCESS;
 176         }
 177
 178         /* set through each element */
 179         nctrls = 0;
 180         *ctrls = LDAP_MALLOC( 1 * sizeof(LDAPControl *) );
 181
 182         if( *ctrls == NULL ) {
 183                 return LDAP_NO_MEMORY;
 184         }
 185
 186         *ctrls[nctrls] = NULL;
 187
 188         for( tag = ber_first_element( ber, &len, &opaque );
 189                 tag != LBER_ERROR;
 190                 tag = ber_next_element( ber, &len, opaque ) )
 191         {
 192                 LDAPControl *tctrl;
 193                 LDAPControl **tctrls;
 194
 195                 tctrl = LDAP_CALLOC( 1, sizeof(LDAPControl) );
 196
 197                 /* allocate pointer space for current controls (nctrls)
 198                  * + this control + extra NULL
 199                  */
 200                 tctrls = (tctrl == NULL) ? NULL :
 201                         LDAP_REALLOC(*ctrls, (nctrls+2) * sizeof(LDAPControl *));
 202
 203                 if( tctrls == NULL ) {
 204                         /* one of the above allocation failed */
 205
 206                         if( tctrl != NULL ) {
 207                                 LDAP_FREE( tctrl );
 208                         }
 209
 210                         ldap_controls_free(*ctrls);
 211                         *ctrls = NULL;
 212
 213                         return LDAP_NO_MEMORY;
 214                 }
 215
 216
 217                 tctrls[nctrls++] = tctrl;
 218                 tctrls[nctrls] = NULL;
 219
 220                 tag = ber_scanf( ber, "{a" /*}*/, &tctrl->ldctl_oid );
 221
 222                 if( tag == LBER_ERROR ) {
 223                         *ctrls = NULL;
 224                         ldap_controls_free( tctrls );
 225                         return LDAP_DECODING_ERROR;
 226                 }
 227
 228                 tag = ber_peek_tag( ber, &len );
 229
 230                 if( tag == LBER_BOOLEAN ) {
 231                         ber_int_t crit;
 232                         tag = ber_scanf( ber, "b", &crit );
 233                         tctrl->ldctl_iscritical = crit ? (char) 0 : (char) ~0;
 234                         tag = ber_peek_tag( ber, &len );
 235                 }
 236
 237                 if( tag == LBER_OCTETSTRING ) {
 238                         tag = ber_scanf( ber, "o", &tctrl->ldctl_value );
 239                 } else {
 240                         BER_BVZERO( &tctrl->ldctl_value );
 241                 }
 242
 243                 *ctrls = tctrls;
 244         }
 245
 246         return LDAP_SUCCESS;
 247 }
 248
 249 /*
 250  * Free a LDAPControl
 251  */
 252 void
 253 ldap_control_free( LDAPControl *c )
 254 {
 255         LDAP_MEMORY_DEBUG_ASSERT( c != NULL );
 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         LDAP_MEMORY_DEBUG_ASSERT( controls != NULL );
 277
 278         if ( controls != NULL ) {
 279                 int i;
 280
 281                 for( i=0; controls[i] != NULL; i++) {
 282                         ldap_control_free( controls[i] );
 283                 }
 284
 285                 LDAP_FREE( controls );
 286         }
 287 }
 288
 289 /*
 290  * Duplicate an array of LDAPControl
 291  */
 292 LDAPControl **
 293 ldap_controls_dup( LDAPControl *const *controls )
 294 {
 295         LDAPControl **new;
 296         int i;
 297
 298         if ( controls == NULL ) {
 299                 return NULL;
 300         }
 301
 302         /* count the controls */
 303         for(i=0; controls[i] != NULL; i++) /* empty */ ;
 304
 305         if( i < 1 ) {
 306                 /* no controls to duplicate */
 307                 return NULL;
 308         }
 309
 310         new = (LDAPControl **) LDAP_MALLOC( (i+1) * sizeof(LDAPControl *) );
 311
 312         if( new == NULL ) {
 313                 /* memory allocation failure */
 314                 return NULL;
 315         }
 316
 317         /* duplicate the controls */
 318         for(i=0; controls[i] != NULL; i++) {
 319                 new[i] = ldap_control_dup( controls[i] );
 320
 321                 if( new[i] == NULL ) {
 322                         ldap_controls_free( new );
 323                         return NULL;
 324                 }
 325         }
 326
 327         new[i] = NULL;
 328
 329         return new;
 330 }
 331
 332 /*
 333  * Duplicate a LDAPControl
 334  */
 335 LDAPControl *
 336 ldap_control_dup( const LDAPControl *c )
 337 {
 338         LDAPControl *new;
 339
 340         if ( c == NULL || c->ldctl_oid == NULL ) {
 341                 return NULL;
 342         }
 343
 344         new = (LDAPControl *) LDAP_MALLOC( sizeof(LDAPControl) );
 345
 346         if( new == NULL ) {
 347                 return NULL;
 348         }
 349
 350         new->ldctl_oid = LDAP_STRDUP( c->ldctl_oid );
 351
 352         if(new->ldctl_oid == NULL) {
 353                 LDAP_FREE( new );
 354                 return NULL;
 355         }
 356
 357         if( c->ldctl_value.bv_val != NULL ) {
 358                 new->ldctl_value.bv_val =
 359                         (char *) LDAP_MALLOC( c->ldctl_value.bv_len + 1 );
 360
 361                 if(new->ldctl_value.bv_val == NULL) {
 362                         if(new->ldctl_oid != NULL) {
 363                                 LDAP_FREE( new->ldctl_oid );
 364                         }
 365                         LDAP_FREE( new );
 366                         return NULL;
 367                 }
 368
 369                 new->ldctl_value.bv_len = c->ldctl_value.bv_len;
 370
 371                 AC_MEMCPY( new->ldctl_value.bv_val, c->ldctl_value.bv_val,
 372                         c->ldctl_value.bv_len );
 373
 374                 new->ldctl_value.bv_val[new->ldctl_value.bv_len] = '\0';
 375
 376         } else {
 377                 new->ldctl_value.bv_len = 0;
 378                 new->ldctl_value.bv_val = NULL;
 379         }
 380
 381         new->ldctl_iscritical = c->ldctl_iscritical;
 382         return new;
 383 }
 384
 385 /*
 386  * Find a LDAPControl - deprecated
 387  */
 388 LDAPControl *
 389 ldap_find_control(
 390         LDAP_CONST char *oid,
 391         LDAPControl **ctrls )
 392 {
 393         if( ctrls == NULL || *ctrls == NULL ) {
 394                 return NULL;
 395         }
 396
 397         for( ; *ctrls != NULL; ctrls++ ) {
 398                 if( strcmp( (*ctrls)->ldctl_oid, oid ) == 0 ) {
 399                         return *ctrls;
 400                 }
 401         }
 402
 403         return NULL;
 404 }
 405
 406 /*
 407  * Find a LDAPControl
 408  */
 409 LDAPControl *
 410 ldap_control_find(
 411         LDAP_CONST char *oid,
 412         LDAPControl **ctrls,
 413         LDAPControl ***nextctrlp )
 414 {
 415         if ( oid == NULL || ctrls == NULL || *ctrls == NULL ) {
 416                 return NULL;
 417         }
 418
 419         for( ; *ctrls != NULL; ctrls++ ) {
 420                 if( strcmp( (*ctrls)->ldctl_oid, oid ) == 0 ) {
 421                         if ( nextctrlp != NULL ) {
 422                                 *nextctrlp = ctrls + 1;
 423                         }
 424
 425                         return *ctrls;
 426                 }
 427         }
 428
 429         if ( nextctrlp != NULL ) {
 430                 *nextctrlp = NULL;
 431         }
 432
 433         return NULL;
 434 }
 435
 436 /*
 437  * Create a LDAPControl, optionally from ber - deprecated
 438  */
 439 int
 440 ldap_create_control(
 441         LDAP_CONST char *requestOID,
 442         BerElement *ber,
 443         int iscritical,
 444         LDAPControl **ctrlp )
 445 {
 446         LDAPControl *ctrl;
 447
 448         assert( requestOID != NULL );
 449         assert( ctrlp != NULL );
 450
 451         ctrl = (LDAPControl *) LDAP_MALLOC( sizeof(LDAPControl) );
 452         if ( ctrl == NULL ) {
 453                 return LDAP_NO_MEMORY;
 454         }
 455
 456         BER_BVZERO(&ctrl->ldctl_value);
 457         if ( ber && ( ber_flatten2( ber, &ctrl->ldctl_value, 1 ) == -1 )) {
 458                 LDAP_FREE( ctrl );
 459                 return LDAP_NO_MEMORY;
 460         }
 461
 462         ctrl->ldctl_oid = LDAP_STRDUP( requestOID );
 463         ctrl->ldctl_iscritical = iscritical;
 464
 465         if ( requestOID != NULL && ctrl->ldctl_oid == NULL ) {
 466                 ldap_control_free( ctrl );
 467                 return LDAP_NO_MEMORY;
 468         }
 469
 470         *ctrlp = ctrl;
 471         return LDAP_SUCCESS;
 472 }
 473
 474 /*
 475  * Create a LDAPControl, optionally from value
 476  */
 477 int
 478 ldap_control_create(
 479         LDAP_CONST char *requestOID,
 480         int iscritical,
 481         struct berval *value,
 482         int dupval,
 483         LDAPControl **ctrlp )
 484 {
 485         LDAPControl *ctrl;
 486
 487         assert( requestOID != NULL );
 488         assert( ctrlp != NULL );
 489
 490         ctrl = (LDAPControl *) LDAP_CALLOC( sizeof(LDAPControl), 1 );
 491         if ( ctrl == NULL ) {
 492                 return LDAP_NO_MEMORY;
 493         }
 494
 495         ctrl->ldctl_iscritical = iscritical;
 496         if ( requestOID != NULL ) {
 497                 ctrl->ldctl_oid = LDAP_STRDUP( requestOID );
 498                 if ( ctrl->ldctl_oid == NULL ) {
 499                         ldap_control_free( ctrl );
 500                         return LDAP_NO_MEMORY;
 501                 }
 502         }
 503
 504         if ( value && !BER_BVISNULL( value ) ) {
 505                 if ( dupval ) {
 506                         ber_dupbv( &ctrl->ldctl_value, value );
 507                         if ( BER_BVISNULL( &ctrl->ldctl_value ) ) {
 508                                 ldap_control_free( ctrl );
 509                                 return LDAP_NO_MEMORY;
 510                         }
 511
 512                 } else {
 513                         ctrl->ldctl_value = *value;
 514                 }
 515         }
 516
 517         *ctrlp = ctrl;
 518
 519         return LDAP_SUCCESS;
 520 }
 521
 522 /*
 523  * check for critical client controls and bitch if present
 524  * if we ever support critical controls, we'll have to
 525  * find a means for maintaining per API call control
 526  * information.
 527  */
 528 int ldap_int_client_controls( LDAP *ld, LDAPControl **ctrls )
 529 {
 530         LDAPControl *const *c;
 531
 532         assert( ld != NULL );
 533         assert( LDAP_VALID( ld ) );
 534
 535         if( ctrls == NULL ) {
 536                 /* use default client controls */
 537                 ctrls = ld->ld_cctrls;
 538         }
 539
 540         if( ctrls == NULL || *ctrls == NULL ) {
 541                 return LDAP_SUCCESS;
 542         }
 543
 544         for( c = ctrls ; *c != NULL; c++ ) {
 545                 if( (*c)->ldctl_iscritical ) {
 546                         ld->ld_errno = LDAP_NOT_SUPPORTED;
 547                         return ld->ld_errno;
 548                 }
 549         }
 550
 551         return LDAP_SUCCESS;
 552 }