git.sur5r.net Git - openldap/blob - libraries/libldap/extended.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 /* Portions Copyright (C) The Internet Society (1997).
  16  * ASN.1 fragments are from RFC 2251; see RFC for full legal notices.
  17  */
  18
  19 /*
  20  * LDAPv3 Extended Operation Request
  21  *      ExtendedRequest ::= [APPLICATION 23] SEQUENCE {
  22  *              requestName      [0] LDAPOID,
  23  *              requestValue     [1] OCTET STRING OPTIONAL
  24  *      }
  25  *
  26  * LDAPv3 Extended Operation Response
  27  *      ExtendedResponse ::= [APPLICATION 24] SEQUENCE {
  28  *              COMPONENTS OF LDAPResult,
  29  *              responseName     [10] LDAPOID OPTIONAL,
  30  *              response         [11] OCTET STRING OPTIONAL
  31  *      }
  32  *
  33  */
  34
  35 #include "portable.h"
  36
  37 #include <stdio.h>
  38 #include <ac/stdlib.h>
  39
  40 #include <ac/socket.h>
  41 #include <ac/string.h>
  42 #include <ac/time.h>
  43
  44 #include "ldap-int.h"
  45 #include "ldap_log.h"
  46
  47 int
  48 ldap_extended_operation(
  49         LDAP                    *ld,
  50         LDAP_CONST char *reqoid,
  51         struct berval   *reqdata,
  52         LDAPControl             **sctrls,
  53         LDAPControl             **cctrls,
  54         int                             *msgidp )
  55 {
  56         BerElement *ber;
  57         int rc;
  58         ber_int_t id;
  59
  60         Debug( LDAP_DEBUG_TRACE, "ldap_extended_operation\n", 0, 0, 0 );
  61
  62         assert( ld != NULL );
  63         assert( LDAP_VALID( ld ) );
  64         assert( reqoid != NULL || *reqoid == '\0' );
  65         assert( msgidp != NULL );
  66
  67         /* must be version 3 (or greater) */
  68         if ( ld->ld_version < LDAP_VERSION3 ) {
  69                 ld->ld_errno = LDAP_NOT_SUPPORTED;
  70                 return( ld->ld_errno );
  71         }
  72
  73         /* create a message to send */
  74         if ( (ber = ldap_alloc_ber_with_options( ld )) == NULL ) {
  75                 ld->ld_errno = LDAP_NO_MEMORY;
  76                 return( ld->ld_errno );
  77         }
  78
  79         LDAP_NEXT_MSGID( ld, id );
  80         if ( reqdata != NULL ) {
  81                 rc = ber_printf( ber, "{it{tstON}", /* '}' */
  82                         id, LDAP_REQ_EXTENDED,
  83                         LDAP_TAG_EXOP_REQ_OID, reqoid,
  84                         LDAP_TAG_EXOP_REQ_VALUE, reqdata );
  85
  86         } else {
  87                 rc = ber_printf( ber, "{it{tsN}", /* '}' */
  88                         id, LDAP_REQ_EXTENDED,
  89                         LDAP_TAG_EXOP_REQ_OID, reqoid );
  90         }
  91
  92         if( rc == -1 ) {
  93                 ld->ld_errno = LDAP_ENCODING_ERROR;
  94                 ber_free( ber, 1 );
  95                 return( ld->ld_errno );
  96         }
  97
  98         /* Put Server Controls */
  99         if( ldap_int_put_controls( ld, sctrls, ber ) != LDAP_SUCCESS ) {
 100                 ber_free( ber, 1 );
 101                 return ld->ld_errno;
 102         }
 103
 104         if ( ber_printf( ber, /*{*/ "N}" ) == -1 ) {
 105                 ld->ld_errno = LDAP_ENCODING_ERROR;
 106                 ber_free( ber, 1 );
 107                 return( ld->ld_errno );
 108         }
 109
 110         /* send the message */
 111         *msgidp = ldap_send_initial_request( ld, LDAP_REQ_EXTENDED, NULL, ber, id );
 112
 113         return( *msgidp < 0 ? ld->ld_errno : LDAP_SUCCESS );
 114 }
 115
 116 int
 117 ldap_extended_operation_s(
 118         LDAP                    *ld,
 119         LDAP_CONST char *reqoid,
 120         struct berval   *reqdata,
 121         LDAPControl             **sctrls,
 122         LDAPControl             **cctrls,
 123         char                    **retoidp,
 124         struct berval   **retdatap )
 125 {
 126     int     rc;
 127     int     msgid;
 128     LDAPMessage *res;
 129
 130         Debug( LDAP_DEBUG_TRACE, "ldap_extended_operation_s\n", 0, 0, 0 );
 131
 132         assert( ld != NULL );
 133         assert( LDAP_VALID( ld ) );
 134         assert( reqoid != NULL || *reqoid == '\0' );
 135         assert( retoidp != NULL || retdatap != NULL );
 136
 137     rc = ldap_extended_operation( ld, reqoid, reqdata,
 138                 sctrls, cctrls, &msgid );
 139
 140     if ( rc != LDAP_SUCCESS ) {
 141         return( rc );
 142         }
 143
 144     if ( ldap_result( ld, msgid, 1, (struct timeval *) NULL, &res ) == -1 ) {
 145         return( ld->ld_errno );
 146         }
 147
 148         if ( retoidp != NULL ) *retoidp = NULL;
 149         if ( retdatap != NULL ) *retdatap = NULL;
 150
 151         rc = ldap_parse_extended_result( ld, res, retoidp, retdatap, 0 );
 152
 153         if( rc != LDAP_SUCCESS ) {
 154                 ldap_msgfree( res );
 155                 return rc;
 156         }
 157
 158     return( ldap_result2error( ld, res, 1 ) );
 159 }
 160
 161 /* Parse an extended result */
 162 int
 163 ldap_parse_extended_result (
 164         LDAP                    *ld,
 165         LDAPMessage             *res,
 166         char                    **retoidp,
 167         struct berval   **retdatap,
 168         int                             freeit )
 169 {
 170         BerElement *ber;
 171         ber_tag_t rc;
 172         ber_tag_t tag;
 173         ber_len_t len;
 174         struct berval *resdata;
 175         ber_int_t errcode;
 176         char *resoid;
 177
 178         assert( ld != NULL );
 179         assert( LDAP_VALID( ld ) );
 180         assert( res != NULL );
 181
 182         Debug( LDAP_DEBUG_TRACE, "ldap_parse_extended_result\n", 0, 0, 0 );
 183
 184         if( ld->ld_version < LDAP_VERSION3 ) {
 185                 ld->ld_errno = LDAP_NOT_SUPPORTED;
 186                 return ld->ld_errno;
 187         }
 188
 189         if( res->lm_msgtype != LDAP_RES_EXTENDED ) {
 190                 ld->ld_errno = LDAP_PARAM_ERROR;
 191                 return ld->ld_errno;
 192         }
 193
 194         if( retoidp != NULL ) *retoidp = NULL;
 195         if( retdatap != NULL ) *retdatap = NULL;
 196
 197         if ( ld->ld_error ) {
 198                 LDAP_FREE( ld->ld_error );
 199                 ld->ld_error = NULL;
 200         }
 201
 202         if ( ld->ld_matched ) {
 203                 LDAP_FREE( ld->ld_matched );
 204                 ld->ld_matched = NULL;
 205         }
 206
 207         ber = ber_dup( res->lm_ber );
 208
 209         if ( ber == NULL ) {
 210                 ld->ld_errno = LDAP_NO_MEMORY;
 211                 return ld->ld_errno;
 212         }
 213
 214         rc = ber_scanf( ber, "{iaa" /*}*/, &errcode,
 215                 &ld->ld_matched, &ld->ld_error );
 216
 217         if( rc == LBER_ERROR ) {
 218                 ld->ld_errno = LDAP_DECODING_ERROR;
 219                 ber_free( ber, 0 );
 220                 return ld->ld_errno;
 221         }
 222
 223         resoid = NULL;
 224         resdata = NULL;
 225
 226         tag = ber_peek_tag( ber, &len );
 227
 228         if( tag == LDAP_TAG_REFERRAL ) {
 229                 /* skip over referral */
 230                 if( ber_scanf( ber, "x" ) == LBER_ERROR ) {
 231                         ld->ld_errno = LDAP_DECODING_ERROR;
 232                         ber_free( ber, 0 );
 233                         return ld->ld_errno;
 234                 }
 235
 236                 tag = ber_peek_tag( ber, &len );
 237         }
 238
 239         if( tag == LDAP_TAG_EXOP_RES_OID ) {
 240                 /* we have a resoid */
 241                 if( ber_scanf( ber, "a", &resoid ) == LBER_ERROR ) {
 242                         ld->ld_errno = LDAP_DECODING_ERROR;
 243                         ber_free( ber, 0 );
 244                         return ld->ld_errno;
 245                 }
 246
 247                 tag = ber_peek_tag( ber, &len );
 248         }
 249
 250         if( tag == LDAP_TAG_EXOP_RES_VALUE ) {
 251                 /* we have a resdata */
 252                 if( ber_scanf( ber, "O", &resdata ) == LBER_ERROR ) {
 253                         ld->ld_errno = LDAP_DECODING_ERROR;
 254                         ber_free( ber, 0 );
 255                         if( resoid != NULL ) LDAP_FREE( resoid );
 256                         return ld->ld_errno;
 257                 }
 258         }
 259
 260         ber_free( ber, 0 );
 261
 262         if( retoidp != NULL ) {
 263                 *retoidp = resoid;
 264         } else {
 265                 LDAP_FREE( resoid );
 266         }
 267
 268         if( retdatap != NULL ) {
 269                 *retdatap = resdata;
 270         } else {
 271                 ber_bvfree( resdata );
 272         }
 273
 274         ld->ld_errno = errcode;
 275
 276         if( freeit ) {
 277                 ldap_msgfree( res );
 278         }
 279
 280         return LDAP_SUCCESS;
 281 }
 282
 283
 284 /* Parse an extended partial */
 285 int
 286 ldap_parse_intermediate (
 287         LDAP                    *ld,
 288         LDAPMessage             *res,
 289         char                    **retoidp,
 290         struct berval   **retdatap,
 291         LDAPControl             ***serverctrls,
 292         int                             freeit )
 293 {
 294         BerElement *ber;
 295         ber_tag_t rc;
 296         ber_tag_t tag;
 297         ber_len_t len;
 298         struct berval *resdata;
 299         char *resoid;
 300
 301         assert( ld != NULL );
 302         assert( LDAP_VALID( ld ) );
 303         assert( res != NULL );
 304
 305         Debug( LDAP_DEBUG_TRACE, "ldap_parse_intermediate\n", 0, 0, 0 );
 306
 307         if( ld->ld_version < LDAP_VERSION3 ) {
 308                 ld->ld_errno = LDAP_NOT_SUPPORTED;
 309                 return ld->ld_errno;
 310         }
 311
 312         if( res->lm_msgtype != LDAP_RES_INTERMEDIATE ) {
 313                 ld->ld_errno = LDAP_PARAM_ERROR;
 314                 return ld->ld_errno;
 315         }
 316
 317         if( retoidp != NULL ) *retoidp = NULL;
 318         if( retdatap != NULL ) *retdatap = NULL;
 319
 320         ber = ber_dup( res->lm_ber );
 321
 322         if ( ber == NULL ) {
 323                 ld->ld_errno = LDAP_NO_MEMORY;
 324                 return ld->ld_errno;
 325         }
 326
 327         rc = ber_scanf( ber, "{" /*}*/ );
 328
 329         if( rc == LBER_ERROR ) {
 330                 ld->ld_errno = LDAP_DECODING_ERROR;
 331                 ber_free( ber, 0 );
 332                 return ld->ld_errno;
 333         }
 334
 335         resoid = NULL;
 336         resdata = NULL;
 337
 338         tag = ber_peek_tag( ber, &len );
 339
 340         /*
 341          * NOTE: accept intermediate and extended response tag values
 342          * as older versions of slapd(8) incorrectly used extended
 343          * response tags.
 344          * Should be removed when 2.2 is moved to Historic.
 345          */
 346         if( tag == LDAP_TAG_IM_RES_OID || tag == LDAP_TAG_EXOP_RES_OID ) {
 347                 /* we have a resoid */
 348                 if( ber_scanf( ber, "a", &resoid ) == LBER_ERROR ) {
 349                         ld->ld_errno = LDAP_DECODING_ERROR;
 350                         ber_free( ber, 0 );
 351                         return ld->ld_errno;
 352                 }
 353
 354                 tag = ber_peek_tag( ber, &len );
 355         }
 356
 357         if( tag == LDAP_TAG_IM_RES_VALUE || tag == LDAP_TAG_EXOP_RES_VALUE ) {
 358                 /* we have a resdata */
 359                 if( ber_scanf( ber, "O", &resdata ) == LBER_ERROR ) {
 360                         ld->ld_errno = LDAP_DECODING_ERROR;
 361                         ber_free( ber, 0 );
 362                         if( resoid != NULL ) LDAP_FREE( resoid );
 363                         return ld->ld_errno;
 364                 }
 365         }
 366
 367         if ( serverctrls == NULL ) {
 368                 rc = LDAP_SUCCESS;
 369                 goto free_and_return;
 370         }
 371
 372         if ( ber_scanf( ber, /*{*/ "}" ) == LBER_ERROR ) {
 373                 rc = LDAP_DECODING_ERROR;
 374                 goto free_and_return;
 375         }
 376
 377         rc = ldap_pvt_get_controls( ber, serverctrls );
 378
 379 free_and_return:
 380         ber_free( ber, 0 );
 381
 382         if( retoidp != NULL ) {
 383                 *retoidp = resoid;
 384         } else {
 385                 LDAP_FREE( resoid );
 386         }
 387
 388         if( retdatap != NULL ) {
 389                 *retdatap = resdata;
 390         } else {
 391                 ber_bvfree( resdata );
 392         }
 393
 394         if( freeit ) {
 395                 ldap_msgfree( res );
 396         }
 397
 398         return LDAP_SUCCESS;
 399 }
 400