git.sur5r.net Git - openldap/blob - libraries/libldap/extended.c

   1 /* $OpenLDAP$ */
   2 /*
   3  * Copyright 1998-1999 The OpenLDAP Foundation, All Rights Reserved.
   4  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
   5  */
   6
   7 /*
   8  * LDAPv3 Extended Operation Request
   9  *      ExtendedRequest ::= [APPLICATION 23] SEQUENCE {
  10  *              requestName      [0] LDAPOID,
  11  *              requestValue     [1] OCTET STRING OPTIONAL
  12  *      }
  13  *
  14  * LDAPv3 Extended Operation Response
  15  *      ExtendedResponse ::= [APPLICATION 24] SEQUENCE {
  16  *              COMPONENTS OF LDAPResult,
  17  *              responseName     [10] LDAPOID OPTIONAL,
  18  *              response         [11] OCTET STRING OPTIONAL
  19  *      }
  20  *
  21  */
  22
  23 #include "portable.h"
  24
  25 #include <stdio.h>
  26 #include <ac/stdlib.h>
  27
  28 #include <ac/socket.h>
  29 #include <ac/string.h>
  30 #include <ac/time.h>
  31
  32 #include "ldap-int.h"
  33
  34 int
  35 ldap_extended_operation(
  36         LDAP                    *ld,
  37         LDAP_CONST char *reqoid,
  38         struct berval   *reqdata,
  39         LDAPControl             **sctrls,
  40         LDAPControl             **cctrls,
  41         int                             *msgidp )
  42 {
  43         BerElement *ber;
  44         int rc;
  45
  46         Debug( LDAP_DEBUG_TRACE, "ldap_extended_operation\n", 0, 0, 0 );
  47
  48         assert( ld != NULL );
  49         assert( LDAP_VALID( ld ) );
  50         assert( reqoid != NULL || *reqoid == '\0' );
  51         assert( msgidp != NULL );
  52
  53         /* must be version 3 (or greater) */
  54         if ( ld->ld_version < LDAP_VERSION3 ) {
  55                 ld->ld_errno = LDAP_NOT_SUPPORTED;
  56                 return( ld->ld_errno );
  57         }
  58
  59         if( reqoid == NULL || *reqoid == '\0' || msgidp == NULL ) {
  60                 ld->ld_errno = LDAP_PARAM_ERROR;
  61                 return( ld->ld_errno );
  62         }
  63
  64         /* create a message to send */
  65         if ( (ber = ldap_alloc_ber_with_options( ld )) == NULL ) {
  66                 ld->ld_errno = LDAP_NO_MEMORY;
  67                 return( ld->ld_errno );
  68         }
  69
  70         if ( reqdata != NULL ) {
  71                 rc = ber_printf( ber, "{it{tstO}", /* '}' */
  72                         ++ld->ld_msgid, LDAP_REQ_EXTENDED,
  73                         LDAP_TAG_EXOP_REQ_OID, reqoid,
  74                         LDAP_TAG_EXOP_REQ_VALUE, reqdata );
  75
  76         } else {
  77                 rc = ber_printf( ber, "{it{ts}", /* '}' */
  78                         ++ld->ld_msgid, LDAP_REQ_EXTENDED,
  79                         LDAP_TAG_EXOP_REQ_OID, reqoid );
  80         }
  81
  82         if( rc == -1 ) {
  83                 ld->ld_errno = LDAP_ENCODING_ERROR;
  84                 ber_free( ber, 1 );
  85                 return( ld->ld_errno );
  86         }
  87
  88         /* Put Server Controls */
  89         if( ldap_int_put_controls( ld, sctrls, ber ) != LDAP_SUCCESS ) {
  90                 ber_free( ber, 1 );
  91                 return ld->ld_errno;
  92         }
  93
  94         if ( ber_printf( ber, /*{*/ "}" ) == -1 ) {
  95                 ld->ld_errno = LDAP_ENCODING_ERROR;
  96                 ber_free( ber, 1 );
  97                 return( ld->ld_errno );
  98         }
  99
 100         /* send the message */
 101         *msgidp = ldap_send_initial_request( ld, LDAP_REQ_EXTENDED, NULL, ber );
 102
 103         return( *msgidp < 0 ? ld->ld_errno : LDAP_SUCCESS );
 104 }
 105
 106 int
 107 ldap_extended_operation_s(
 108         LDAP                    *ld,
 109         LDAP_CONST char *reqoid,
 110         struct berval   *reqdata,
 111         LDAPControl             **sctrls,
 112         LDAPControl             **cctrls,
 113         char                    **retoidp,
 114         struct berval   **retdatap )
 115 {
 116     int     rc;
 117     int     msgid;
 118     LDAPMessage *res;
 119
 120         Debug( LDAP_DEBUG_TRACE, "ldap_extended_operation_s\n", 0, 0, 0 );
 121
 122         assert( ld != NULL );
 123         assert( LDAP_VALID( ld ) );
 124         assert( reqoid != NULL || *reqoid == '\0' );
 125         assert( retoidp != NULL || retdatap != NULL );
 126
 127         if( retoidp == NULL || retdatap == NULL ) {
 128                 ld->ld_errno = LDAP_PARAM_ERROR;
 129                 return( ld->ld_errno );
 130         }
 131
 132     rc = ldap_extended_operation( ld, reqoid, reqdata,
 133                 sctrls, cctrls, &msgid );
 134
 135     if ( rc != LDAP_SUCCESS ) {
 136         return( rc );
 137         }
 138
 139     if ( ldap_result( ld, msgid, 1, (struct timeval *) NULL, &res ) == -1 ) {
 140         return( ld->ld_errno );
 141         }
 142
 143         *retoidp = NULL;
 144         *retdatap = NULL;
 145
 146         rc = ldap_parse_extended_result( ld, res, retoidp, retdatap, 0 );
 147
 148         if( rc != LDAP_SUCCESS ) {
 149                 ldap_msgfree( res );
 150                 return rc;
 151         }
 152
 153     return( ldap_result2error( ld, res, 1 ) );
 154 }
 155
 156 /* Parse an extended result */
 157 int
 158 ldap_parse_extended_result (
 159         LDAP                    *ld,
 160         LDAPMessage             *res,
 161         char                    **retoidp,
 162         struct berval   **retdatap,
 163         int                             freeit )
 164 {
 165         BerElement *ber;
 166         ber_tag_t rc;
 167         ber_tag_t tag;
 168         ber_len_t len;
 169         struct berval *resdata;
 170         ber_int_t errcode;
 171         char *resoid;
 172
 173         assert( ld != NULL );
 174         assert( LDAP_VALID( ld ) );
 175         assert( res != NULL );
 176
 177         Debug( LDAP_DEBUG_TRACE, "ldap_parse_extended_result\n", 0, 0, 0 );
 178
 179         if( ld->ld_version < LDAP_VERSION3 ) {
 180                 ld->ld_errno = LDAP_NOT_SUPPORTED;
 181                 return ld->ld_errno;
 182         }
 183
 184         if( res->lm_msgtype == LDAP_RES_EXTENDED ) {
 185                 ld->ld_errno = LDAP_PARAM_ERROR;
 186                 return ld->ld_errno;
 187         }
 188
 189         if( retoidp != NULL ) *retoidp = NULL;
 190         if( retdatap != NULL ) *retdatap = NULL;
 191
 192         ber = ber_dup( res->lm_ber );
 193
 194         if ( ld->ld_error ) {
 195                 LDAP_FREE( ld->ld_error );
 196                 ld->ld_error = NULL;
 197         }
 198
 199         if ( ld->ld_matched ) {
 200                 LDAP_FREE( ld->ld_matched );
 201                 ld->ld_matched = NULL;
 202         }
 203
 204         rc = ber_scanf( ber, "{iaa" /*}*/, &errcode,
 205                 &ld->ld_matched, &ld->ld_matched );
 206
 207         if( rc == LBER_ERROR ) {
 208                 ld->ld_errno = LDAP_DECODING_ERROR;
 209                 ber_free( ber, 0 );
 210                 return ld->ld_errno;
 211         }
 212
 213         resoid = NULL;
 214         resdata = NULL;
 215
 216         tag = ber_peek_tag( ber, &len );
 217
 218         if( tag == LDAP_TAG_REFERRAL ) {
 219                 /* skip over referral */
 220                 tag = ber_scanf( ber, "x" );
 221
 222                 if( tag != LBER_ERROR ) {
 223                         tag = ber_peek_tag( ber, &len );
 224                 }
 225         }
 226
 227         if( tag == LDAP_TAG_EXOP_RES_OID ) {
 228                 /* we have a resoid */
 229                 if( ber_scanf( ber, "a", &resoid ) == LBER_ERROR ) {
 230                         ld->ld_errno = LDAP_DECODING_ERROR;
 231                         ber_free( ber, 0 );
 232                         return ld->ld_errno;
 233                 }
 234
 235                 tag = ber_peek_tag( ber, &len );
 236         }
 237
 238         if( tag == LDAP_TAG_EXOP_RES_VALUE ) {
 239                 /* we have a resdata */
 240                 if( ber_scanf( ber, "O", &resoid ) == LBER_ERROR ) {
 241                         ld->ld_errno = LDAP_DECODING_ERROR;
 242                         ber_free( ber, 0 );
 243                         if( resoid != NULL ) LDAP_FREE( resoid );
 244                         return ld->ld_errno;
 245                 }
 246         }
 247
 248         if( retoidp != NULL ) {
 249                 *retoidp = resoid;
 250         } else {
 251                 LDAP_FREE( resoid );
 252         }
 253
 254         if( retdatap != NULL ) {
 255                 *retdatap = resdata;
 256         } else {
 257                 ber_bvfree( resdata );
 258         }
 259
 260         ld->ld_errno = errcode;
 261
 262         if( freeit ) {
 263                 ldap_msgfree( res );
 264         }
 265
 266         return LDAP_SUCCESS;
 267 }