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