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-2010 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 #if defined( HAVE_CYRUS_SASL )
 430         LDAP_MUTEX_LOCK( &ldap_int_sasl_mutex );
 431 #endif
 432 #ifdef LDAP_CONNECTIONLESS
 433         if( LDAP_IS_UDP(ld) ) {
 434                 /* Just force it to simple bind, silly to make the user
 435                  * ask all the time. No, we don't ever actually bind, but I'll
 436                  * let the final bind handler take care of saving the cdn.
 437                  */
 438                 rc = ldap_simple_bind( ld, dn, NULL );
 439                 rc = rc < 0 ? rc : 0;
 440                 goto done;
 441         } else
 442 #endif
 443
 444         /* First time */
 445         if ( !result ) {
 446
 447 #ifdef HAVE_CYRUS_SASL
 448         if( mechs == NULL || *mechs == '\0' ) {
 449                 mechs = ld->ld_options.ldo_def_sasl_mech;
 450         }
 451 #endif
 452
 453         if( mechs == NULL || *mechs == '\0' ) {
 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_s: 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_s: 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 defined( HAVE_CYRUS_SASL )
 477         LDAP_MUTEX_UNLOCK( &ldap_int_sasl_mutex );
 478 #endif
 479         if ( smechs ) LDAP_FREE( smechs );
 480
 481         return rc;
 482 }
 483
 484 /*
 485  * ldap_sasl_interactive_bind_s - interactive SASL authentication
 486  *
 487  * This routine uses interactive callbacks.
 488  *
 489  * LDAP_SUCCESS is returned upon success, the ldap error code
 490  * otherwise.
 491  */
 492 int
 493 ldap_sasl_interactive_bind_s(
 494         LDAP *ld,
 495         LDAP_CONST char *dn, /* usually NULL */
 496         LDAP_CONST char *mechs,
 497         LDAPControl **serverControls,
 498         LDAPControl **clientControls,
 499         unsigned flags,
 500         LDAP_SASL_INTERACT_PROC *interact,
 501         void *defaults )
 502 {
 503         const char *rmech = NULL;
 504         LDAPMessage *result = NULL;
 505         int rc, msgid;
 506
 507         do {
 508                 rc = ldap_sasl_interactive_bind( ld, dn, mechs,
 509                         serverControls, clientControls,
 510                         flags, interact, defaults, result, &rmech, &msgid );
 511
 512                 if ( rc != LDAP_SASL_BIND_IN_PROGRESS )
 513                         break;
 514
 515 #ifdef LDAP_CONNECTIONLESS
 516                 if (LDAP_IS_UDP(ld)) {
 517                         break;
 518                 }
 519 #endif
 520
 521                 if ( ldap_result( ld, msgid, LDAP_MSG_ALL, NULL, &result ) == -1 || !result ) {
 522                         return( ld->ld_errno ); /* ldap_result sets ld_errno */
 523                 }
 524         } while ( rc == LDAP_SASL_BIND_IN_PROGRESS );
 525
 526         return rc;
 527 }
 528
 529 #ifdef HAVE_CYRUS_SASL
 530
 531 #ifdef HAVE_SASL_SASL_H
 532 #include <sasl/sasl.h>
 533 #else
 534 #include <sasl.h>
 535 #endif
 536
 537 #endif /* HAVE_CYRUS_SASL */
 538
 539 static int
 540 sb_sasl_generic_remove( Sockbuf_IO_Desc *sbiod );
 541
 542 static int
 543 sb_sasl_generic_setup( Sockbuf_IO_Desc *sbiod, void *arg )
 544 {
 545         struct sb_sasl_generic_data     *p;
 546         struct sb_sasl_generic_install  *i;
 547
 548         assert( sbiod != NULL );
 549
 550         i = (struct sb_sasl_generic_install *)arg;
 551
 552         p = LBER_MALLOC( sizeof( *p ) );
 553         if ( p == NULL )
 554                 return -1;
 555         p->ops = i->ops;
 556         p->ops_private = i->ops_private;
 557         p->sbiod = sbiod;
 558         p->flags = 0;
 559         ber_pvt_sb_buf_init( &p->sec_buf_in );
 560         ber_pvt_sb_buf_init( &p->buf_in );
 561         ber_pvt_sb_buf_init( &p->buf_out );
 562
 563         sbiod->sbiod_pvt = p;
 564
 565         p->ops->init( p, &p->min_send, &p->max_send, &p->max_recv );
 566
 567         if ( ber_pvt_sb_grow_buffer( &p->sec_buf_in, p->min_send ) < 0 ) {
 568                 sb_sasl_generic_remove( sbiod );
 569                 sock_errset(ENOMEM);
 570                 return -1;
 571         }
 572
 573         return 0;
 574 }
 575
 576 static int
 577 sb_sasl_generic_remove( Sockbuf_IO_Desc *sbiod )
 578 {
 579         struct sb_sasl_generic_data     *p;
 580
 581         assert( sbiod != NULL );
 582
 583         p = (struct sb_sasl_generic_data *)sbiod->sbiod_pvt;
 584
 585         p->ops->fini(p);
 586
 587         ber_pvt_sb_buf_destroy( &p->sec_buf_in );
 588         ber_pvt_sb_buf_destroy( &p->buf_in );
 589         ber_pvt_sb_buf_destroy( &p->buf_out );
 590         LBER_FREE( p );
 591         sbiod->sbiod_pvt = NULL;
 592         return 0;
 593 }
 594
 595 static ber_len_t
 596 sb_sasl_generic_pkt_length(
 597         struct sb_sasl_generic_data *p,
 598         const unsigned char *buf,
 599         int debuglevel )
 600 {
 601         ber_len_t               size;
 602
 603         assert( buf != NULL );
 604
 605         size = buf[0] << 24
 606                 | buf[1] << 16
 607                 | buf[2] << 8
 608                 | buf[3];
 609
 610         if ( size > p->max_recv ) {
 611                 /* somebody is trying to mess me up. */
 612                 ber_log_printf( LDAP_DEBUG_ANY, debuglevel,
 613                         "sb_sasl_generic_pkt_length: "
 614                         "received illegal packet length of %lu bytes\n",
 615                         (unsigned long)size );
 616                 size = 16; /* this should lead to an error. */
 617         }
 618
 619         return size + 4; /* include the size !!! */
 620 }
 621
 622 /* Drop a processed packet from the input buffer */
 623 static void
 624 sb_sasl_generic_drop_packet (
 625         struct sb_sasl_generic_data *p,
 626         int debuglevel )
 627 {
 628         ber_slen_t                      len;
 629
 630         len = p->sec_buf_in.buf_ptr - p->sec_buf_in.buf_end;
 631         if ( len > 0 )
 632                 AC_MEMCPY( p->sec_buf_in.buf_base, p->sec_buf_in.buf_base +
 633                         p->sec_buf_in.buf_end, len );
 634
 635         if ( len >= 4 ) {
 636                 p->sec_buf_in.buf_end = sb_sasl_generic_pkt_length(p,
 637                         (unsigned char *) p->sec_buf_in.buf_base, debuglevel);
 638         }
 639         else {
 640                 p->sec_buf_in.buf_end = 0;
 641         }
 642         p->sec_buf_in.buf_ptr = len;
 643 }
 644
 645 static ber_slen_t
 646 sb_sasl_generic_read( Sockbuf_IO_Desc *sbiod, void *buf, ber_len_t len)
 647 {
 648         struct sb_sasl_generic_data     *p;
 649         ber_slen_t                      ret, bufptr;
 650
 651         assert( sbiod != NULL );
 652         assert( SOCKBUF_VALID( sbiod->sbiod_sb ) );
 653
 654         p = (struct sb_sasl_generic_data *)sbiod->sbiod_pvt;
 655
 656         /* Are there anything left in the buffer? */
 657         ret = ber_pvt_sb_copy_out( &p->buf_in, buf, len );
 658         bufptr = ret;
 659         len -= ret;
 660
 661         if ( len == 0 )
 662                 return bufptr;
 663
 664         p->ops->reset_buf( p, &p->buf_in );
 665
 666         /* Read the length of the packet */
 667         while ( p->sec_buf_in.buf_ptr < 4 ) {
 668                 ret = LBER_SBIOD_READ_NEXT( sbiod, p->sec_buf_in.buf_base +
 669                         p->sec_buf_in.buf_ptr,
 670                         4 - p->sec_buf_in.buf_ptr );
 671 #ifdef EINTR
 672                 if ( ( ret < 0 ) && ( errno == EINTR ) )
 673                         continue;
 674 #endif
 675                 if ( ret <= 0 )
 676                         return bufptr ? bufptr : ret;
 677
 678                 p->sec_buf_in.buf_ptr += ret;
 679         }
 680
 681         /* The new packet always starts at p->sec_buf_in.buf_base */
 682         ret = sb_sasl_generic_pkt_length(p, (unsigned char *) p->sec_buf_in.buf_base,
 683                 sbiod->sbiod_sb->sb_debug );
 684
 685         /* Grow the packet buffer if neccessary */
 686         if ( ( p->sec_buf_in.buf_size < (ber_len_t) ret ) &&
 687                 ber_pvt_sb_grow_buffer( &p->sec_buf_in, ret ) < 0 )
 688         {
 689                 sock_errset(ENOMEM);
 690                 return -1;
 691         }
 692         p->sec_buf_in.buf_end = ret;
 693
 694         /* Did we read the whole encrypted packet? */
 695         while ( p->sec_buf_in.buf_ptr < p->sec_buf_in.buf_end ) {
 696                 /* No, we have got only a part of it */
 697                 ret = p->sec_buf_in.buf_end - p->sec_buf_in.buf_ptr;
 698
 699                 ret = LBER_SBIOD_READ_NEXT( sbiod, p->sec_buf_in.buf_base +
 700                         p->sec_buf_in.buf_ptr, ret );
 701 #ifdef EINTR
 702                 if ( ( ret < 0 ) && ( errno == EINTR ) )
 703                         continue;
 704 #endif
 705                 if ( ret <= 0 )
 706                         return bufptr ? bufptr : ret;
 707
 708                 p->sec_buf_in.buf_ptr += ret;
 709         }
 710
 711         /* Decode the packet */
 712         ret = p->ops->decode( p, &p->sec_buf_in, &p->buf_in );
 713
 714         /* Drop the packet from the input buffer */
 715         sb_sasl_generic_drop_packet( p, sbiod->sbiod_sb->sb_debug );
 716
 717         if ( ret != 0 ) {
 718                 ber_log_printf( LDAP_DEBUG_ANY, sbiod->sbiod_sb->sb_debug,
 719                         "sb_sasl_generic_read: failed to decode packet\n" );
 720                 sock_errset(EIO);
 721                 return -1;
 722         }
 723
 724         bufptr += ber_pvt_sb_copy_out( &p->buf_in, (char*) buf + bufptr, len );
 725
 726         return bufptr;
 727 }
 728
 729 static ber_slen_t
 730 sb_sasl_generic_write( Sockbuf_IO_Desc *sbiod, void *buf, ber_len_t len)
 731 {
 732         struct sb_sasl_generic_data     *p;
 733         int                             ret;
 734         ber_len_t                       len2;
 735
 736         assert( sbiod != NULL );
 737         assert( SOCKBUF_VALID( sbiod->sbiod_sb ) );
 738
 739         p = (struct sb_sasl_generic_data *)sbiod->sbiod_pvt;
 740
 741         /* Is there anything left in the buffer? */
 742         if ( p->buf_out.buf_ptr != p->buf_out.buf_end ) {
 743                 ret = ber_pvt_sb_do_write( sbiod, &p->buf_out );
 744                 if ( ret < 0 ) return ret;
 745
 746                 /* Still have something left?? */
 747                 if ( p->buf_out.buf_ptr != p->buf_out.buf_end ) {
 748                         sock_errset(EAGAIN);
 749                         return -1;
 750                 }
 751         }
 752
 753         len2 = p->max_send - 100;       /* For safety margin */
 754         len2 = len > len2 ? len2 : len;
 755
 756         /* If we're just retrying a partial write, tell the
 757          * caller it's done. Let them call again if there's
 758          * still more left to write.
 759          */
 760         if ( p->flags & LDAP_PVT_SASL_PARTIAL_WRITE ) {
 761                 p->flags ^= LDAP_PVT_SASL_PARTIAL_WRITE;
 762                 return len2;
 763         }
 764
 765         /* now encode the next packet. */
 766         p->ops->reset_buf( p, &p->buf_out );
 767
 768         ret = p->ops->encode( p, buf, len2, &p->buf_out );
 769
 770         if ( ret != 0 ) {
 771                 ber_log_printf( LDAP_DEBUG_ANY, sbiod->sbiod_sb->sb_debug,
 772                         "sb_sasl_generic_write: failed to encode packet\n" );
 773                 sock_errset(EIO);
 774                 return -1;
 775         }
 776
 777         ret = ber_pvt_sb_do_write( sbiod, &p->buf_out );
 778
 779         if ( ret < 0 ) {
 780                 /* error? */
 781                 int err = sock_errno();
 782                 /* caller can retry this */
 783                 if ( err == EAGAIN || err == EWOULDBLOCK || err == EINTR )
 784                         p->flags |= LDAP_PVT_SASL_PARTIAL_WRITE;
 785                 return ret;
 786         } else if ( p->buf_out.buf_ptr != p->buf_out.buf_end ) {
 787                 /* partial write? pretend nothing got written */
 788                 p->flags |= LDAP_PVT_SASL_PARTIAL_WRITE;
 789                 sock_errset(EAGAIN);
 790                 len2 = -1;
 791         }
 792
 793         /* return number of bytes encoded, not written, to ensure
 794          * no byte is encoded twice (even if only sent once).
 795          */
 796         return len2;
 797 }
 798
 799 static int
 800 sb_sasl_generic_ctrl( Sockbuf_IO_Desc *sbiod, int opt, void *arg )
 801 {
 802         struct sb_sasl_generic_data     *p;
 803
 804         p = (struct sb_sasl_generic_data *)sbiod->sbiod_pvt;
 805
 806         if ( opt == LBER_SB_OPT_DATA_READY ) {
 807                 if ( p->buf_in.buf_ptr != p->buf_in.buf_end ) return 1;
 808         }
 809
 810         return LBER_SBIOD_CTRL_NEXT( sbiod, opt, arg );
 811 }
 812
 813 Sockbuf_IO ldap_pvt_sockbuf_io_sasl_generic = {
 814         sb_sasl_generic_setup,          /* sbi_setup */
 815         sb_sasl_generic_remove,         /* sbi_remove */
 816         sb_sasl_generic_ctrl,           /* sbi_ctrl */
 817         sb_sasl_generic_read,           /* sbi_read */
 818         sb_sasl_generic_write,          /* sbi_write */
 819         NULL                    /* sbi_close */
 820 };
 821
 822 int ldap_pvt_sasl_generic_install(
 823         Sockbuf *sb,
 824         struct sb_sasl_generic_install *install_arg )
 825 {
 826         Debug( LDAP_DEBUG_TRACE, "ldap_pvt_sasl_generic_install\n",
 827                 0, 0, 0 );
 828
 829         /* don't install the stuff unless security has been negotiated */
 830
 831         if ( !ber_sockbuf_ctrl( sb, LBER_SB_OPT_HAS_IO,
 832                         &ldap_pvt_sockbuf_io_sasl_generic ) )
 833         {
 834 #ifdef LDAP_DEBUG
 835                 ber_sockbuf_add_io( sb, &ber_sockbuf_io_debug,
 836                         LBER_SBIOD_LEVEL_APPLICATION, (void *)"sasl_generic_" );
 837 #endif
 838                 ber_sockbuf_add_io( sb, &ldap_pvt_sockbuf_io_sasl_generic,
 839                         LBER_SBIOD_LEVEL_APPLICATION, install_arg );
 840         }
 841
 842         return LDAP_SUCCESS;
 843 }
 844
 845 void ldap_pvt_sasl_generic_remove( Sockbuf *sb )
 846 {
 847         ber_sockbuf_remove_io( sb, &ldap_pvt_sockbuf_io_sasl_generic,
 848                 LBER_SBIOD_LEVEL_APPLICATION );
 849 #ifdef LDAP_DEBUG
 850         ber_sockbuf_remove_io( sb, &ber_sockbuf_io_debug,
 851                 LBER_SBIOD_LEVEL_APPLICATION );
 852 #endif
 853 }