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

   1 /* $OpenLDAP$ */
   2 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
   3  *
   4  * Copyright 1998-2014 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
  16 /*
  17  *      BindRequest ::= SEQUENCE {
  18  *              version         INTEGER,
  19  *              name            DistinguishedName,       -- who
  20  *              authentication  CHOICE {
  21  *                      simple          [0] OCTET STRING -- passwd
  22  *                      krbv42ldap      [1] OCTET STRING -- OBSOLETE
  23  *                      krbv42dsa       [2] OCTET STRING -- OBSOLETE
  24  *                      sasl            [3] SaslCredentials     -- LDAPv3
  25  *              }
  26  *      }
  27  *
  28  *      BindResponse ::= SEQUENCE {
  29  *              COMPONENTS OF LDAPResult,
  30  *              serverSaslCreds         OCTET STRING OPTIONAL -- LDAPv3
  31  *      }
  32  *
  33  */
  34
  35 #include "portable.h"
  36
  37 #include <stdio.h>
  38
  39 #include <ac/socket.h>
  40 #include <ac/stdlib.h>
  41 #include <ac/string.h>
  42 #include <ac/time.h>
  43 #include <ac/errno.h>
  44
  45 #include "ldap-int.h"
  46
  47 /*
  48  * ldap_sasl_bind - bind to the ldap server (and X.500).
  49  * The dn (usually NULL), mechanism, and credentials are provided.
  50  * The message id of the request initiated is provided upon successful
  51  * (LDAP_SUCCESS) return.
  52  *
  53  * Example:
  54  *      ldap_sasl_bind( ld, NULL, "mechanism",
  55  *              cred, NULL, NULL, &msgid )
  56  */
  57
  58 int
  59 ldap_sasl_bind(
  60         LDAP                    *ld,
  61         LDAP_CONST char *dn,
  62         LDAP_CONST char *mechanism,
  63         struct berval   *cred,
  64         LDAPControl             **sctrls,
  65         LDAPControl             **cctrls,
  66         int                             *msgidp )
  67 {
  68         BerElement      *ber;
  69         int rc;
  70         ber_int_t id;
  71
  72         Debug( LDAP_DEBUG_TRACE, "ldap_sasl_bind\n", 0, 0, 0 );
  73
  74         assert( ld != NULL );
  75         assert( LDAP_VALID( ld ) );
  76         assert( msgidp != NULL );
  77
  78         /* check client controls */
  79         rc = ldap_int_client_controls( ld, cctrls );
  80         if( rc != LDAP_SUCCESS ) return rc;
  81
  82         if( mechanism == LDAP_SASL_SIMPLE ) {
  83                 if( dn == NULL && cred != NULL && cred->bv_len ) {
  84                         /* use default binddn */
  85                         dn = ld->ld_defbinddn;
  86                 }
  87
  88         } else if( ld->ld_version < LDAP_VERSION3 ) {
  89                 ld->ld_errno = LDAP_NOT_SUPPORTED;
  90                 return ld->ld_errno;
  91         }
  92
  93         if ( dn == NULL ) {
  94                 dn = "";
  95         }
  96
  97         /* create a message to send */
  98         if ( (ber = ldap_alloc_ber_with_options( ld )) == NULL ) {
  99                 ld->ld_errno = LDAP_NO_MEMORY;
 100                 return ld->ld_errno;
 101         }
 102
 103         assert( LBER_VALID( ber ) );
 104
 105         LDAP_NEXT_MSGID( ld, id );
 106         if( mechanism == LDAP_SASL_SIMPLE ) {
 107                 /* simple bind */
 108                 rc = ber_printf( ber, "{it{istON}" /*}*/,
 109                         id, LDAP_REQ_BIND,
 110                         ld->ld_version, dn, LDAP_AUTH_SIMPLE,
 111                         cred );
 112
 113         } else if ( cred == NULL || cred->bv_val == NULL ) {
 114                 /* SASL bind w/o credentials */
 115                 rc = ber_printf( ber, "{it{ist{sN}N}" /*}*/,
 116                         id, LDAP_REQ_BIND,
 117                         ld->ld_version, dn, LDAP_AUTH_SASL,
 118                         mechanism );
 119
 120         } else {
 121                 /* SASL bind w/ credentials */
 122                 rc = ber_printf( ber, "{it{ist{sON}N}" /*}*/,
 123                         id, LDAP_REQ_BIND,
 124                         ld->ld_version, dn, LDAP_AUTH_SASL,
 125                         mechanism, cred );
 126         }
 127
 128         if( rc == -1 ) {
 129                 ld->ld_errno = LDAP_ENCODING_ERROR;
 130                 ber_free( ber, 1 );
 131                 return( -1 );
 132         }
 133
 134         /* Put Server Controls */
 135         if( ldap_int_put_controls( ld, sctrls, ber ) != LDAP_SUCCESS ) {
 136                 ber_free( ber, 1 );
 137                 return ld->ld_errno;
 138         }
 139
 140         if ( ber_printf( ber, /*{*/ "N}" ) == -1 ) {
 141                 ld->ld_errno = LDAP_ENCODING_ERROR;
 142                 ber_free( ber, 1 );
 143                 return ld->ld_errno;
 144         }
 145
 146
 147         /* send the message */
 148         *msgidp = ldap_send_initial_request( ld, LDAP_REQ_BIND, dn, ber, id );
 149
 150         if(*msgidp < 0)
 151                 return ld->ld_errno;
 152
 153         return LDAP_SUCCESS;
 154 }
 155
 156
 157 int
 158 ldap_sasl_bind_s(
 159         LDAP                    *ld,
 160         LDAP_CONST char *dn,
 161         LDAP_CONST char *mechanism,
 162         struct berval   *cred,
 163         LDAPControl             **sctrls,
 164         LDAPControl             **cctrls,
 165         struct berval   **servercredp )
 166 {
 167         int     rc, msgid;
 168         LDAPMessage     *result;
 169         struct berval   *scredp = NULL;
 170
 171         Debug( LDAP_DEBUG_TRACE, "ldap_sasl_bind_s\n", 0, 0, 0 );
 172
 173         /* do a quick !LDAPv3 check... ldap_sasl_bind will do the rest. */
 174         if( servercredp != NULL ) {
 175                 if (ld->ld_version < LDAP_VERSION3) {
 176                         ld->ld_errno = LDAP_NOT_SUPPORTED;
 177                         return ld->ld_errno;
 178                 }
 179                 *servercredp = NULL;
 180         }
 181
 182         rc = ldap_sasl_bind( ld, dn, mechanism, cred, sctrls, cctrls, &msgid );
 183
 184         if ( rc != LDAP_SUCCESS ) {
 185                 return( rc );
 186         }
 187
 188 #ifdef LDAP_CONNECTIONLESS
 189         if (LDAP_IS_UDP(ld)) {
 190                 return( rc );
 191         }
 192 #endif
 193
 194         if ( ldap_result( ld, msgid, LDAP_MSG_ALL, NULL, &result ) == -1 || !result ) {
 195                 return( ld->ld_errno ); /* ldap_result sets ld_errno */
 196         }
 197
 198         /* parse the results */
 199         scredp = NULL;
 200         if( servercredp != NULL ) {
 201                 rc = ldap_parse_sasl_bind_result( ld, result, &scredp, 0 );
 202         }
 203
 204         if ( rc != LDAP_SUCCESS ) {
 205                 ldap_msgfree( result );
 206                 return( rc );
 207         }
 208
 209         rc = ldap_result2error( ld, result, 1 );
 210
 211         if ( rc == LDAP_SUCCESS || rc == LDAP_SASL_BIND_IN_PROGRESS ) {
 212                 if( servercredp != NULL ) {
 213                         *servercredp = scredp;
 214                         scredp = NULL;
 215                 }
 216         }
 217
 218         if ( scredp != NULL ) {
 219                 ber_bvfree(scredp);
 220         }
 221
 222         return rc;
 223 }
 224
 225
 226 /*
 227 * Parse BindResponse:
 228 *
 229 *   BindResponse ::= [APPLICATION 1] SEQUENCE {
 230 *     COMPONENTS OF LDAPResult,
 231 *     serverSaslCreds  [7] OCTET STRING OPTIONAL }
 232 *
 233 *   LDAPResult ::= SEQUENCE {
 234 *     resultCode      ENUMERATED,
 235 *     matchedDN       LDAPDN,
 236 *     errorMessage    LDAPString,
 237 *     referral        [3] Referral OPTIONAL }
 238 */
 239
 240 int
 241 ldap_parse_sasl_bind_result(
 242         LDAP                    *ld,
 243         LDAPMessage             *res,
 244         struct berval   **servercredp,
 245         int                             freeit )
 246 {
 247         ber_int_t errcode;
 248         struct berval* scred;
 249
 250         ber_tag_t tag;
 251         BerElement      *ber;
 252
 253         Debug( LDAP_DEBUG_TRACE, "ldap_parse_sasl_bind_result\n", 0, 0, 0 );
 254
 255         assert( ld != NULL );
 256         assert( LDAP_VALID( ld ) );
 257         assert( res != NULL );
 258
 259         if( servercredp != NULL ) {
 260                 if( ld->ld_version < LDAP_VERSION2 ) {
 261                         return LDAP_NOT_SUPPORTED;
 262                 }
 263                 *servercredp = NULL;
 264         }
 265
 266         if( res->lm_msgtype != LDAP_RES_BIND ) {
 267                 ld->ld_errno = LDAP_PARAM_ERROR;
 268                 return ld->ld_errno;
 269         }
 270
 271         scred = NULL;
 272
 273         if ( ld->ld_error ) {
 274                 LDAP_FREE( ld->ld_error );
 275                 ld->ld_error = NULL;
 276         }
 277         if ( ld->ld_matched ) {
 278                 LDAP_FREE( ld->ld_matched );
 279                 ld->ld_matched = NULL;
 280         }
 281
 282         /* parse results */
 283
 284         ber = ber_dup( res->lm_ber );
 285
 286         if( ber == NULL ) {
 287                 ld->ld_errno = LDAP_NO_MEMORY;
 288                 return ld->ld_errno;
 289         }
 290
 291         if ( ld->ld_version < LDAP_VERSION2 ) {
 292                 tag = ber_scanf( ber, "{iA}",
 293                         &errcode, &ld->ld_error );
 294
 295                 if( tag == LBER_ERROR ) {
 296                         ber_free( ber, 0 );
 297                         ld->ld_errno = LDAP_DECODING_ERROR;
 298                         return ld->ld_errno;
 299                 }
 300
 301         } else {
 302                 ber_len_t len;
 303
 304                 tag = ber_scanf( ber, "{eAA" /*}*/,
 305                         &errcode, &ld->ld_matched, &ld->ld_error );
 306
 307                 if( tag == LBER_ERROR ) {
 308                         ber_free( ber, 0 );
 309                         ld->ld_errno = LDAP_DECODING_ERROR;
 310                         return ld->ld_errno;
 311                 }
 312
 313                 tag = ber_peek_tag(ber, &len);
 314
 315                 if( tag == LDAP_TAG_REFERRAL ) {
 316                         /* skip 'em */
 317                         if( ber_scanf( ber, "x" ) == LBER_ERROR ) {
 318                                 ber_free( ber, 0 );
 319                                 ld->ld_errno = LDAP_DECODING_ERROR;
 320                                 return ld->ld_errno;
 321                         }
 322
 323                         tag = ber_peek_tag(ber, &len);
 324                 }
 325
 326                 if( tag == LDAP_TAG_SASL_RES_CREDS ) {
 327                         if( ber_scanf( ber, "O", &scred ) == LBER_ERROR ) {
 328                                 ber_free( ber, 0 );
 329                                 ld->ld_errno = LDAP_DECODING_ERROR;
 330                                 return ld->ld_errno;
 331                         }
 332                 }
 333         }
 334
 335         ber_free( ber, 0 );
 336
 337         if ( servercredp != NULL ) {
 338                 *servercredp = scred;
 339
 340         } else if ( scred != NULL ) {
 341                 ber_bvfree( scred );
 342         }
 343
 344         ld->ld_errno = errcode;
 345
 346         if ( freeit ) {
 347                 ldap_msgfree( res );
 348         }
 349
 350         return( LDAP_SUCCESS );
 351 }
 352
 353 int
 354 ldap_pvt_sasl_getmechs ( LDAP *ld, char **pmechlist )
 355 {
 356         /* we need to query the server for supported mechs anyway */
 357         LDAPMessage *res, *e;
 358         char *attrs[] = { "supportedSASLMechanisms", NULL };
 359         char **values, *mechlist;
 360         int rc;
 361
 362         Debug( LDAP_DEBUG_TRACE, "ldap_pvt_sasl_getmech\n", 0, 0, 0 );
 363
 364         rc = ldap_search_s( ld, "", LDAP_SCOPE_BASE,
 365                 NULL, attrs, 0, &res );
 366
 367         if ( rc != LDAP_SUCCESS ) {
 368                 return ld->ld_errno;
 369         }
 370
 371         e = ldap_first_entry( ld, res );
 372         if ( e == NULL ) {
 373                 ldap_msgfree( res );
 374                 if ( ld->ld_errno == LDAP_SUCCESS ) {
 375                         ld->ld_errno = LDAP_NO_SUCH_OBJECT;
 376                 }
 377                 return ld->ld_errno;
 378         }
 379
 380         values = ldap_get_values( ld, e, "supportedSASLMechanisms" );
 381         if ( values == NULL ) {
 382                 ldap_msgfree( res );
 383                 ld->ld_errno = LDAP_NO_SUCH_ATTRIBUTE;
 384                 return ld->ld_errno;
 385         }
 386
 387         mechlist = ldap_charray2str( values, " " );
 388         if ( mechlist == NULL ) {
 389                 LDAP_VFREE( values );
 390                 ldap_msgfree( res );
 391                 ld->ld_errno = LDAP_NO_MEMORY;
 392                 return ld->ld_errno;
 393         }
 394
 395         LDAP_VFREE( values );
 396         ldap_msgfree( res );
 397
 398         *pmechlist = mechlist;
 399
 400         return LDAP_SUCCESS;
 401 }
 402
 403 /*
 404  * ldap_sasl_interactive_bind - interactive SASL authentication
 405  *
 406  * This routine uses interactive callbacks.
 407  *
 408  * LDAP_SUCCESS is returned upon success, the ldap error code
 409  * otherwise. LDAP_SASL_BIND_IN_PROGRESS is returned if further
 410  * calls are needed.
 411  */
 412 int
 413 ldap_sasl_interactive_bind(
 414         LDAP *ld,
 415         LDAP_CONST char *dn, /* usually NULL */
 416         LDAP_CONST char *mechs,
 417         LDAPControl **serverControls,
 418         LDAPControl **clientControls,
 419         unsigned flags,
 420         LDAP_SASL_INTERACT_PROC *interact,
 421         void *defaults,
 422         LDAPMessage *result,
 423         const char **rmech,
 424         int *msgid )
 425 {
 426         char *smechs = NULL;
 427         int rc;
 428
 429 #ifdef LDAP_CONNECTIONLESS
 430         if( LDAP_IS_UDP(ld) ) {
 431                 /* Just force it to simple bind, silly to make the user
 432                  * ask all the time. No, we don't ever actually bind, but I'll
 433                  * let the final bind handler take care of saving the cdn.
 434                  */
 435                 rc = ldap_simple_bind( ld, dn, NULL );
 436                 rc = rc < 0 ? rc : 0;
 437                 goto done;
 438         } else
 439 #endif
 440
 441         /* First time */
 442         if ( !result ) {
 443
 444 #ifdef HAVE_CYRUS_SASL
 445         if( mechs == NULL || *mechs == '\0' ) {
 446                 mechs = ld->ld_options.ldo_def_sasl_mech;
 447         }
 448 #endif
 449
 450         if( mechs == NULL || *mechs == '\0' ) {
 451                 /* FIXME: this needs to be asynchronous too;
 452                  * perhaps NULL should be disallowed for async usage?
 453                  */
 454                 rc = ldap_pvt_sasl_getmechs( ld, &smechs );
 455                 if( rc != LDAP_SUCCESS ) {
 456                         goto done;
 457                 }
 458
 459                 Debug( LDAP_DEBUG_TRACE,
 460                         "ldap_sasl_interactive_bind: server supports: %s\n",
 461                         smechs, 0, 0 );
 462
 463                 mechs = smechs;
 464
 465         } else {
 466                 Debug( LDAP_DEBUG_TRACE,
 467                         "ldap_sasl_interactive_bind: user selected: %s\n",
 468                         mechs, 0, 0 );
 469         }
 470         }
 471         rc = ldap_int_sasl_bind( ld, dn, mechs,
 472                 serverControls, clientControls,
 473                 flags, interact, defaults, result, rmech, msgid );
 474
 475 done:
 476         if ( smechs ) LDAP_FREE( smechs );
 477
 478         return rc;
 479 }
 480
 481 /*
 482  * ldap_sasl_interactive_bind_s - interactive SASL authentication
 483  *
 484  * This routine uses interactive callbacks.
 485  *
 486  * LDAP_SUCCESS is returned upon success, the ldap error code
 487  * otherwise.
 488  */
 489 int
 490 ldap_sasl_interactive_bind_s(
 491         LDAP *ld,
 492         LDAP_CONST char *dn, /* usually NULL */
 493         LDAP_CONST char *mechs,
 494         LDAPControl **serverControls,
 495         LDAPControl **clientControls,
 496         unsigned flags,
 497         LDAP_SASL_INTERACT_PROC *interact,
 498         void *defaults )
 499 {
 500         const char *rmech = NULL;
 501         LDAPMessage *result = NULL;
 502         int rc, msgid;
 503
 504         do {
 505                 rc = ldap_sasl_interactive_bind( ld, dn, mechs,
 506                         serverControls, clientControls,
 507                         flags, interact, defaults, result, &rmech, &msgid );
 508
 509                 ldap_msgfree( result );
 510
 511                 if ( rc != LDAP_SASL_BIND_IN_PROGRESS )
 512                         break;
 513
 514 #ifdef LDAP_CONNECTIONLESS
 515                 if (LDAP_IS_UDP(ld)) {
 516                         break;
 517                 }
 518 #endif
 519
 520                 if ( ldap_result( ld, msgid, LDAP_MSG_ALL, NULL, &result ) == -1 || !result ) {
 521                         return( ld->ld_errno ); /* ldap_result sets ld_errno */
 522                 }
 523         } while ( rc == LDAP_SASL_BIND_IN_PROGRESS );
 524
 525         return rc;
 526 }
 527
 528 #ifdef HAVE_CYRUS_SASL
 529
 530 #ifdef HAVE_SASL_SASL_H
 531 #include <sasl/sasl.h>
 532 #else
 533 #include <sasl.h>
 534 #endif
 535
 536 #endif /* HAVE_CYRUS_SASL */
 537
 538 static int
 539 sb_sasl_generic_remove( Sockbuf_IO_Desc *sbiod );
 540
 541 static int
 542 sb_sasl_generic_setup( Sockbuf_IO_Desc *sbiod, void *arg )
 543 {
 544         struct sb_sasl_generic_data     *p;
 545         struct sb_sasl_generic_install  *i;
 546
 547         assert( sbiod != NULL );
 548
 549         i = (struct sb_sasl_generic_install *)arg;
 550
 551         p = LBER_MALLOC( sizeof( *p ) );
 552         if ( p == NULL )
 553                 return -1;
 554         p->ops = i->ops;
 555         p->ops_private = i->ops_private;
 556         p->sbiod = sbiod;
 557         p->flags = 0;
 558         ber_pvt_sb_buf_init( &p->sec_buf_in );
 559         ber_pvt_sb_buf_init( &p->buf_in );
 560         ber_pvt_sb_buf_init( &p->buf_out );
 561
 562         sbiod->sbiod_pvt = p;
 563
 564         p->ops->init( p, &p->min_send, &p->max_send, &p->max_recv );
 565
 566         if ( ber_pvt_sb_grow_buffer( &p->sec_buf_in, p->min_send ) < 0 ) {
 567                 sb_sasl_generic_remove( sbiod );
 568                 sock_errset(ENOMEM);
 569                 return -1;
 570         }
 571
 572         return 0;
 573 }
 574
 575 static int
 576 sb_sasl_generic_remove( Sockbuf_IO_Desc *sbiod )
 577 {
 578         struct sb_sasl_generic_data     *p;
 579
 580         assert( sbiod != NULL );
 581
 582         p = (struct sb_sasl_generic_data *)sbiod->sbiod_pvt;
 583
 584         p->ops->fini(p);
 585
 586         ber_pvt_sb_buf_destroy( &p->sec_buf_in );
 587         ber_pvt_sb_buf_destroy( &p->buf_in );
 588         ber_pvt_sb_buf_destroy( &p->buf_out );
 589         LBER_FREE( p );
 590         sbiod->sbiod_pvt = NULL;
 591         return 0;
 592 }
 593
 594 static ber_len_t
 595 sb_sasl_generic_pkt_length(
 596         struct sb_sasl_generic_data *p,
 597         const unsigned char *buf,
 598         int debuglevel )
 599 {
 600         ber_len_t               size;
 601
 602         assert( buf != NULL );
 603
 604         size = buf[0] << 24
 605                 | buf[1] << 16
 606                 | buf[2] << 8
 607                 | buf[3];
 608
 609         if ( size > p->max_recv ) {
 610                 /* somebody is trying to mess me up. */
 611                 ber_log_printf( LDAP_DEBUG_ANY, debuglevel,
 612                         "sb_sasl_generic_pkt_length: "
 613                         "received illegal packet length of %lu bytes\n",
 614                         (unsigned long)size );
 615                 size = 16; /* this should lead to an error. */
 616         }
 617
 618         return size + 4; /* include the size !!! */
 619 }
 620
 621 /* Drop a processed packet from the input buffer */
 622 static void
 623 sb_sasl_generic_drop_packet (
 624         struct sb_sasl_generic_data *p,
 625         int debuglevel )
 626 {
 627         ber_slen_t                      len;
 628
 629         len = p->sec_buf_in.buf_ptr - p->sec_buf_in.buf_end;
 630         if ( len > 0 )
 631                 AC_MEMCPY( p->sec_buf_in.buf_base, p->sec_buf_in.buf_base +
 632                         p->sec_buf_in.buf_end, len );
 633
 634         if ( len >= 4 ) {
 635                 p->sec_buf_in.buf_end = sb_sasl_generic_pkt_length(p,
 636                         (unsigned char *) p->sec_buf_in.buf_base, debuglevel);
 637         }
 638         else {
 639                 p->sec_buf_in.buf_end = 0;
 640         }
 641         p->sec_buf_in.buf_ptr = len;
 642 }
 643
 644 static ber_slen_t
 645 sb_sasl_generic_read( Sockbuf_IO_Desc *sbiod, void *buf, ber_len_t len)
 646 {
 647         struct sb_sasl_generic_data     *p;
 648         ber_slen_t                      ret, bufptr;
 649
 650         assert( sbiod != NULL );
 651         assert( SOCKBUF_VALID( sbiod->sbiod_sb ) );
 652
 653         p = (struct sb_sasl_generic_data *)sbiod->sbiod_pvt;
 654
 655         /* Are there anything left in the buffer? */
 656         ret = ber_pvt_sb_copy_out( &p->buf_in, buf, len );
 657         bufptr = ret;
 658         len -= ret;
 659
 660         if ( len == 0 )
 661                 return bufptr;
 662
 663         p->ops->reset_buf( p, &p->buf_in );
 664
 665         /* Read the length of the packet */
 666         while ( p->sec_buf_in.buf_ptr < 4 ) {
 667                 ret = LBER_SBIOD_READ_NEXT( sbiod, p->sec_buf_in.buf_base +
 668                         p->sec_buf_in.buf_ptr,
 669                         4 - p->sec_buf_in.buf_ptr );
 670 #ifdef EINTR
 671                 if ( ( ret < 0 ) && ( errno == EINTR ) )
 672                         continue;
 673 #endif
 674                 if ( ret <= 0 )
 675                         return bufptr ? bufptr : ret;
 676
 677                 p->sec_buf_in.buf_ptr += ret;
 678         }
 679
 680         /* The new packet always starts at p->sec_buf_in.buf_base */
 681         ret = sb_sasl_generic_pkt_length(p, (unsigned char *) p->sec_buf_in.buf_base,
 682                 sbiod->sbiod_sb->sb_debug );
 683
 684         /* Grow the packet buffer if neccessary */
 685         if ( ( p->sec_buf_in.buf_size < (ber_len_t) ret ) &&
 686                 ber_pvt_sb_grow_buffer( &p->sec_buf_in, ret ) < 0 )
 687         {
 688                 sock_errset(ENOMEM);
 689                 return -1;
 690         }
 691         p->sec_buf_in.buf_end = ret;
 692
 693         /* Did we read the whole encrypted packet? */
 694         while ( p->sec_buf_in.buf_ptr < p->sec_buf_in.buf_end ) {
 695                 /* No, we have got only a part of it */
 696                 ret = p->sec_buf_in.buf_end - p->sec_buf_in.buf_ptr;
 697
 698                 ret = LBER_SBIOD_READ_NEXT( sbiod, p->sec_buf_in.buf_base +
 699                         p->sec_buf_in.buf_ptr, ret );
 700 #ifdef EINTR
 701                 if ( ( ret < 0 ) && ( errno == EINTR ) )
 702                         continue;
 703 #endif
 704                 if ( ret <= 0 )
 705                         return bufptr ? bufptr : ret;
 706
 707                 p->sec_buf_in.buf_ptr += ret;
 708         }
 709
 710         /* Decode the packet */
 711         ret = p->ops->decode( p, &p->sec_buf_in, &p->buf_in );
 712
 713         /* Drop the packet from the input buffer */
 714         sb_sasl_generic_drop_packet( p, sbiod->sbiod_sb->sb_debug );
 715
 716         if ( ret != 0 ) {
 717                 ber_log_printf( LDAP_DEBUG_ANY, sbiod->sbiod_sb->sb_debug,
 718                         "sb_sasl_generic_read: failed to decode packet\n" );
 719                 sock_errset(EIO);
 720                 return -1;
 721         }
 722
 723         bufptr += ber_pvt_sb_copy_out( &p->buf_in, (char*) buf + bufptr, len );
 724
 725         return bufptr;
 726 }
 727
 728 static ber_slen_t
 729 sb_sasl_generic_write( Sockbuf_IO_Desc *sbiod, void *buf, ber_len_t len)
 730 {
 731         struct sb_sasl_generic_data     *p;
 732         int                             ret;
 733         ber_len_t                       len2;
 734
 735         assert( sbiod != NULL );
 736         assert( SOCKBUF_VALID( sbiod->sbiod_sb ) );
 737
 738         p = (struct sb_sasl_generic_data *)sbiod->sbiod_pvt;
 739
 740         /* Is there anything left in the buffer? */
 741         if ( p->buf_out.buf_ptr != p->buf_out.buf_end ) {
 742                 ret = ber_pvt_sb_do_write( sbiod, &p->buf_out );
 743                 if ( ret < 0 ) return ret;
 744
 745                 /* Still have something left?? */
 746                 if ( p->buf_out.buf_ptr != p->buf_out.buf_end ) {
 747                         sock_errset(EAGAIN);
 748                         return -1;
 749                 }
 750         }
 751
 752         len2 = p->max_send - 100;       /* For safety margin */
 753         len2 = len > len2 ? len2 : len;
 754
 755         /* If we're just retrying a partial write, tell the
 756          * caller it's done. Let them call again if there's
 757          * still more left to write.
 758          */
 759         if ( p->flags & LDAP_PVT_SASL_PARTIAL_WRITE ) {
 760                 p->flags ^= LDAP_PVT_SASL_PARTIAL_WRITE;
 761                 return len2;
 762         }
 763
 764         /* now encode the next packet. */
 765         p->ops->reset_buf( p, &p->buf_out );
 766
 767         ret = p->ops->encode( p, buf, len2, &p->buf_out );
 768
 769         if ( ret != 0 ) {
 770                 ber_log_printf( LDAP_DEBUG_ANY, sbiod->sbiod_sb->sb_debug,
 771                         "sb_sasl_generic_write: failed to encode packet\n" );
 772                 sock_errset(EIO);
 773                 return -1;
 774         }
 775
 776         ret = ber_pvt_sb_do_write( sbiod, &p->buf_out );
 777
 778         if ( ret < 0 ) {
 779                 /* error? */
 780                 int err = sock_errno();
 781                 /* caller can retry this */
 782                 if ( err == EAGAIN || err == EWOULDBLOCK || err == EINTR )
 783                         p->flags |= LDAP_PVT_SASL_PARTIAL_WRITE;
 784                 return ret;
 785         } else if ( p->buf_out.buf_ptr != p->buf_out.buf_end ) {
 786                 /* partial write? pretend nothing got written */
 787                 p->flags |= LDAP_PVT_SASL_PARTIAL_WRITE;
 788                 sock_errset(EAGAIN);
 789                 len2 = -1;
 790         }
 791
 792         /* return number of bytes encoded, not written, to ensure
 793          * no byte is encoded twice (even if only sent once).
 794          */
 795         return len2;
 796 }
 797
 798 static int
 799 sb_sasl_generic_ctrl( Sockbuf_IO_Desc *sbiod, int opt, void *arg )
 800 {
 801         struct sb_sasl_generic_data     *p;
 802
 803         p = (struct sb_sasl_generic_data *)sbiod->sbiod_pvt;
 804
 805         if ( opt == LBER_SB_OPT_DATA_READY ) {
 806                 if ( p->buf_in.buf_ptr != p->buf_in.buf_end ) return 1;
 807         }
 808
 809         return LBER_SBIOD_CTRL_NEXT( sbiod, opt, arg );
 810 }
 811
 812 Sockbuf_IO ldap_pvt_sockbuf_io_sasl_generic = {
 813         sb_sasl_generic_setup,          /* sbi_setup */
 814         sb_sasl_generic_remove,         /* sbi_remove */
 815         sb_sasl_generic_ctrl,           /* sbi_ctrl */
 816         sb_sasl_generic_read,           /* sbi_read */
 817         sb_sasl_generic_write,          /* sbi_write */
 818         NULL                    /* sbi_close */
 819 };
 820
 821 int ldap_pvt_sasl_generic_install(
 822         Sockbuf *sb,
 823         struct sb_sasl_generic_install *install_arg )
 824 {
 825         Debug( LDAP_DEBUG_TRACE, "ldap_pvt_sasl_generic_install\n",
 826                 0, 0, 0 );
 827
 828         /* don't install the stuff unless security has been negotiated */
 829
 830         if ( !ber_sockbuf_ctrl( sb, LBER_SB_OPT_HAS_IO,
 831                         &ldap_pvt_sockbuf_io_sasl_generic ) )
 832         {
 833 #ifdef LDAP_DEBUG
 834                 ber_sockbuf_add_io( sb, &ber_sockbuf_io_debug,
 835                         LBER_SBIOD_LEVEL_APPLICATION, (void *)"sasl_generic_" );
 836 #endif
 837                 ber_sockbuf_add_io( sb, &ldap_pvt_sockbuf_io_sasl_generic,
 838                         LBER_SBIOD_LEVEL_APPLICATION, install_arg );
 839         }
 840
 841         return LDAP_SUCCESS;
 842 }
 843
 844 void ldap_pvt_sasl_generic_remove( Sockbuf *sb )
 845 {
 846         ber_sockbuf_remove_io( sb, &ldap_pvt_sockbuf_io_sasl_generic,
 847                 LBER_SBIOD_LEVEL_APPLICATION );
 848 #ifdef LDAP_DEBUG
 849         ber_sockbuf_remove_io( sb, &ber_sockbuf_io_debug,
 850                 LBER_SBIOD_LEVEL_APPLICATION );
 851 #endif
 852 }