external/bsd/openldap/dist/libraries/liblber/sockbuf.c

   1 /* sockbuf.c - i/o routines with support for adding i/o layers. */
   2 /* $OpenLDAP: pkg/ldap/libraries/liblber/sockbuf.c,v 1.65.2.4 2008/02/11 23:26:41 kurt Exp $ */
   3 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
   4  *
   5  * Copyright 1998-2008 The OpenLDAP Foundation.
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted only as authorized by the OpenLDAP
  10  * Public License.
  11  *
  12  * A copy of this license is available in the file LICENSE in the
  13  * top-level directory of the distribution or, alternatively, at
  14  * <http://www.OpenLDAP.org/license.html>.
  15  */
  16
  17 #include "portable.h"
  18
  19 #include <stdio.h>
  20
  21 #include <ac/stdlib.h>
  22
  23 #include <ac/ctype.h>
  24 #include <ac/errno.h>
  25 #include <ac/socket.h>
  26 #include <ac/string.h>
  27 #include <ac/unistd.h>
  28
  29 #ifdef HAVE_IO_H
  30 #include <io.h>
  31 #endif /* HAVE_IO_H */
  32
  33 #if defined( HAVE_FCNTL_H )
  34 #include <fcntl.h>
  35 #endif
  36
  37 #if defined( HAVE_SYS_FILIO_H )
  38 #include <sys/filio.h>
  39 #elif defined( HAVE_SYS_IOCTL_H )
  40 #include <sys/ioctl.h>
  41 #endif
  42
  43 #include "lber-int.h"
  44
  45 #ifndef LBER_MIN_BUFF_SIZE
  46 #define LBER_MIN_BUFF_SIZE              4096
  47 #endif
  48 #ifndef LBER_MAX_BUFF_SIZE
  49 #define LBER_MAX_BUFF_SIZE              (65536*256)
  50 #endif
  51 #ifndef LBER_DEFAULT_READAHEAD
  52 #define LBER_DEFAULT_READAHEAD  16384
  53 #endif
  54
  55 Sockbuf *
  56 ber_sockbuf_alloc( void )
  57 {
  58         Sockbuf                 *sb;
  59
  60         sb = LBER_CALLOC( 1, sizeof( Sockbuf ) );
  61
  62         if( sb == NULL ) return NULL;
  63
  64         ber_int_sb_init( sb );
  65         return sb;
  66 }
  67
  68 void
  69 ber_sockbuf_free( Sockbuf *sb )
  70 {
  71         assert( sb != NULL );
  72         assert( SOCKBUF_VALID( sb ) );
  73
  74         ber_int_sb_close( sb );
  75         ber_int_sb_destroy( sb );
  76         LBER_FREE( sb );
  77 }
  78
  79 /* Return values: -1: error, 0: no operation performed or the answer is false,
  80  * 1: successful operation or the answer is true
  81  */
  82 int
  83 ber_sockbuf_ctrl( Sockbuf *sb, int opt, void *arg )
  84 {
  85         Sockbuf_IO_Desc         *p;
  86         int                     ret = 0;
  87
  88         assert( sb != NULL );
  89         assert( SOCKBUF_VALID( sb ) );
  90
  91         switch ( opt ) {
  92                 case LBER_SB_OPT_HAS_IO:
  93                         p = sb->sb_iod;
  94                         while ( p && p->sbiod_io != (Sockbuf_IO *)arg ) {
  95                                 p = p->sbiod_next;
  96                         }
  97
  98                         if ( p ) {
  99                                 ret = 1;
 100                         }
 101                         break;
 102
 103                 case LBER_SB_OPT_GET_FD:
 104                         if ( arg != NULL ) {
 105                                 *((ber_socket_t *)arg) = sb->sb_fd;
 106                         }
 107                         ret = ( sb->sb_fd == AC_SOCKET_INVALID ? -1 : 1);
 108                         break;
 109
 110                 case LBER_SB_OPT_SET_FD:
 111                         sb->sb_fd = *((ber_socket_t *)arg);
 112                         ret = 1;
 113                         break;
 114
 115                 case LBER_SB_OPT_SET_NONBLOCK:
 116                         ret = ber_pvt_socket_set_nonblock( sb->sb_fd, arg != NULL)
 117                                 ? -1 : 1;
 118                         break;
 119
 120                 case LBER_SB_OPT_DRAIN: {
 121                                 /* Drain the data source to enable possible errors (e.g.
 122                                  * TLS) to be propagated to the upper layers
 123                                  */
 124                                 char buf[LBER_MIN_BUFF_SIZE];
 125
 126                                 do {
 127                                         ret = ber_int_sb_read( sb, buf, sizeof( buf ) );
 128                                 } while ( ret == sizeof( buf ) );
 129
 130                                 ret = 1;
 131                         } break;
 132
 133                 case LBER_SB_OPT_NEEDS_READ:
 134                         ret = ( sb->sb_trans_needs_read ? 1 : 0 );
 135                         break;
 136
 137                 case LBER_SB_OPT_NEEDS_WRITE:
 138                         ret = ( sb->sb_trans_needs_write ? 1 : 0 );
 139                         break;
 140
 141                 case LBER_SB_OPT_GET_MAX_INCOMING:
 142                         if ( arg != NULL ) {
 143                                 *((ber_len_t *)arg) = sb->sb_max_incoming;
 144                         }
 145                         ret = 1;
 146                         break;
 147
 148                 case LBER_SB_OPT_SET_MAX_INCOMING:
 149                         sb->sb_max_incoming = *((ber_len_t *)arg);
 150                         ret = 1;
 151                         break;
 152
 153                 case LBER_SB_OPT_UNGET_BUF:
 154 #ifdef LDAP_PF_LOCAL_SENDMSG
 155                         sb->sb_ungetlen = ((struct berval *)arg)->bv_len;
 156                         if ( sb->sb_ungetlen <= sizeof( sb->sb_ungetbuf )) {
 157                                 AC_MEMCPY( sb->sb_ungetbuf, ((struct berval *)arg)->bv_val,
 158                                         sb->sb_ungetlen );
 159                                 ret = 1;
 160                         } else {
 161                                 sb->sb_ungetlen = 0;
 162                                 ret = -1;
 163                         }
 164 #endif
 165                         break;
 166
 167                 default:
 168                         ret = sb->sb_iod->sbiod_io->sbi_ctrl( sb->sb_iod, opt, arg );
 169                         break;
 170    }
 171
 172         return ret;
 173 }
 174
 175 int
 176 ber_sockbuf_add_io( Sockbuf *sb, Sockbuf_IO *sbio, int layer, void *arg )
 177 {
 178         Sockbuf_IO_Desc         *d, *p, **q;
 179
 180         assert( sb != NULL );
 181         assert( SOCKBUF_VALID( sb ) );
 182
 183         if ( sbio == NULL ) {
 184                 return -1;
 185         }
 186
 187         q = &sb->sb_iod;
 188         p = *q;
 189         while ( p && p->sbiod_level > layer ) {
 190                 q = &p->sbiod_next;
 191                 p = *q;
 192         }
 193
 194         d = LBER_MALLOC( sizeof( *d ) );
 195         if ( d == NULL ) {
 196                 return -1;
 197         }
 198
 199         d->sbiod_level = layer;
 200         d->sbiod_sb = sb;
 201         d->sbiod_io = sbio;
 202         memset( &d->sbiod_pvt, '\0', sizeof( d->sbiod_pvt ) );
 203         d->sbiod_next = p;
 204         *q = d;
 205
 206         if ( sbio->sbi_setup != NULL && ( sbio->sbi_setup( d, arg ) < 0 ) ) {
 207                 return -1;
 208         }
 209
 210         return 0;
 211 }
 212
 213 int
 214 ber_sockbuf_remove_io( Sockbuf *sb, Sockbuf_IO *sbio, int layer )
 215 {
 216         Sockbuf_IO_Desc         *p, **q;
 217
 218         assert( sb != NULL );
 219         assert( SOCKBUF_VALID( sb ) );
 220
 221         if ( sb->sb_iod == NULL ) {
 222                 return -1;
 223         }
 224
 225         q = &sb->sb_iod;
 226         while ( *q != NULL ) {
 227                 p = *q;
 228                 if ( layer == p->sbiod_level && p->sbiod_io == sbio ) {
 229                         if ( p->sbiod_io->sbi_remove != NULL &&
 230                                 p->sbiod_io->sbi_remove( p ) < 0 )
 231                         {
 232                                 return -1;
 233                         }
 234                         *q = p->sbiod_next;
 235                         LBER_FREE( p );
 236                         break;
 237                 }
 238                 q = &p->sbiod_next;
 239         }
 240
 241         return 0;
 242 }
 243
 244 void
 245 ber_pvt_sb_buf_init( Sockbuf_Buf *buf )
 246 {
 247         buf->buf_base = NULL;
 248         buf->buf_ptr = 0;
 249         buf->buf_end = 0;
 250         buf->buf_size = 0;
 251 }
 252
 253 void
 254 ber_pvt_sb_buf_destroy( Sockbuf_Buf *buf )
 255 {
 256         assert( buf != NULL);
 257
 258         if (buf->buf_base) {
 259                 LBER_FREE( buf->buf_base );
 260         }
 261         ber_pvt_sb_buf_init( buf );
 262 }
 263
 264 int
 265 ber_pvt_sb_grow_buffer( Sockbuf_Buf *buf, ber_len_t minsize )
 266 {
 267         ber_len_t               pw;
 268         char                    *p;
 269
 270         assert( buf != NULL );
 271
 272         for ( pw = LBER_MIN_BUFF_SIZE; pw < minsize; pw <<= 1 ) {
 273                 if (pw > LBER_MAX_BUFF_SIZE) return -1;
 274         }
 275
 276         if ( buf->buf_size < pw ) {
 277                 p = LBER_REALLOC( buf->buf_base, pw );
 278                 if ( p == NULL ) return -1;
 279                 buf->buf_base = p;
 280                 buf->buf_size = pw;
 281         }
 282         return 0;
 283 }
 284
 285 ber_len_t
 286 ber_pvt_sb_copy_out( Sockbuf_Buf *sbb, char *buf, ber_len_t len )
 287 {
 288         ber_len_t               max;
 289
 290         assert( buf != NULL );
 291         assert( sbb != NULL );
 292 #if 0
 293         assert( sbb->buf_size > 0 );
 294 #endif
 295
 296         max = sbb->buf_end - sbb->buf_ptr;
 297         max = ( max < len) ? max : len;
 298         if ( max ) {
 299                 AC_MEMCPY( buf, sbb->buf_base + sbb->buf_ptr, max );
 300                 sbb->buf_ptr += max;
 301                 if ( sbb->buf_ptr >= sbb->buf_end ) {
 302                         sbb->buf_ptr = sbb->buf_end = 0;
 303                 }
 304    }
 305         return max;
 306 }
 307
 308 ber_slen_t
 309 ber_pvt_sb_do_write( Sockbuf_IO_Desc *sbiod, Sockbuf_Buf *buf_out )
 310 {
 311         ber_len_t               to_go;
 312         ber_slen_t ret;
 313
 314         assert( sbiod != NULL );
 315         assert( SOCKBUF_VALID( sbiod->sbiod_sb ) );
 316
 317         to_go = buf_out->buf_end - buf_out->buf_ptr;
 318         assert( to_go > 0 );
 319
 320         for(;;) {
 321                 ret = LBER_SBIOD_WRITE_NEXT( sbiod, buf_out->buf_base +
 322                         buf_out->buf_ptr, to_go );
 323 #ifdef EINTR
 324                 if ((ret<0) && (errno==EINTR)) continue;
 325 #endif
 326                 break;
 327         }
 328
 329         if ( ret <= 0 ) return ret;
 330
 331         buf_out->buf_ptr += ret;
 332         if (buf_out->buf_ptr == buf_out->buf_end) {
 333                 buf_out->buf_end = buf_out->buf_ptr = 0;
 334         }
 335
 336         return ret;
 337 }
 338
 339 int
 340 ber_pvt_socket_set_nonblock( ber_socket_t sd, int nb )
 341 {
 342 #ifdef HAVE_FCNTL
 343         int flags = fcntl( sd, F_GETFL);
 344         if( nb ) {
 345                 flags |= O_NONBLOCK;
 346         } else {
 347                 flags &= ~O_NONBLOCK;
 348         }
 349         return fcntl( sd, F_SETFL, flags );
 350
 351 #elif defined( FIONBIO )
 352         ioctl_t status = nb ? 1 : 0;
 353         return ioctl( sd, FIONBIO, &status );
 354 #endif
 355 }
 356
 357 int
 358 ber_int_sb_init( Sockbuf *sb )
 359 {
 360         assert( sb != NULL);
 361
 362         sb->sb_valid=LBER_VALID_SOCKBUF;
 363         sb->sb_options = 0;
 364         sb->sb_debug = ber_int_debug;
 365         sb->sb_fd = AC_SOCKET_INVALID;
 366         sb->sb_iod = NULL;
 367         sb->sb_trans_needs_read = 0;
 368         sb->sb_trans_needs_write = 0;
 369
 370         assert( SOCKBUF_VALID( sb ) );
 371         return 0;
 372 }
 373
 374 int
 375 ber_int_sb_close( Sockbuf *sb )
 376 {
 377         Sockbuf_IO_Desc         *p;
 378
 379         assert( sb != NULL);
 380
 381         p = sb->sb_iod;
 382         while ( p ) {
 383                 if ( p->sbiod_io->sbi_close && p->sbiod_io->sbi_close( p ) < 0 ) {
 384                         return -1;
 385                 }
 386                 p = p->sbiod_next;
 387         }
 388
 389         sb->sb_fd = AC_SOCKET_INVALID;
 390
 391         return 0;
 392 }
 393
 394 int
 395 ber_int_sb_destroy( Sockbuf *sb )
 396 {
 397         Sockbuf_IO_Desc         *p;
 398
 399         assert( sb != NULL);
 400         assert( SOCKBUF_VALID( sb ) );
 401
 402         while ( sb->sb_iod ) {
 403                 p = sb->sb_iod->sbiod_next;
 404                 ber_sockbuf_remove_io( sb, sb->sb_iod->sbiod_io,
 405                         sb->sb_iod->sbiod_level );
 406                 sb->sb_iod = p;
 407         }
 408
 409         return ber_int_sb_init( sb );
 410 }
 411
 412 ber_slen_t
 413 ber_int_sb_read( Sockbuf *sb, void *buf, ber_len_t len )
 414 {
 415         ber_slen_t              ret;
 416
 417         assert( buf != NULL );
 418         assert( sb != NULL);
 419         assert( sb->sb_iod != NULL );
 420         assert( SOCKBUF_VALID( sb ) );
 421
 422         for (;;) {
 423                 ret = sb->sb_iod->sbiod_io->sbi_read( sb->sb_iod, buf, len );
 424
 425 #ifdef EINTR
 426                 if ( ( ret < 0 ) && ( errno == EINTR ) ) continue;
 427 #endif
 428                 break;
 429         }
 430
 431         return ret;
 432 }
 433
 434 ber_slen_t
 435 ber_int_sb_write( Sockbuf *sb, void *buf, ber_len_t len )
 436 {
 437         ber_slen_t              ret;
 438
 439         assert( buf != NULL );
 440         assert( sb != NULL);
 441         assert( sb->sb_iod != NULL );
 442         assert( SOCKBUF_VALID( sb ) );
 443
 444         for (;;) {
 445                 ret = sb->sb_iod->sbiod_io->sbi_write( sb->sb_iod, buf, len );
 446
 447 #ifdef EINTR
 448                 if ( ( ret < 0 ) && ( errno == EINTR ) ) continue;
 449 #endif
 450                 break;
 451         }
 452
 453         return ret;
 454 }
 455
 456 /*
 457  * Support for TCP
 458  */
 459
 460 static ber_slen_t
 461 sb_stream_read( Sockbuf_IO_Desc *sbiod, void *buf, ber_len_t len )
 462 {
 463         assert( sbiod != NULL);
 464         assert( SOCKBUF_VALID( sbiod->sbiod_sb ) );
 465
 466 #if defined(MACOS)
 467 /*
 468  * MacTCP/OpenTransport
 469  */
 470         return tcpread( sbiod->sbiod_sb->sb_fd, 0, (unsigned char *)buf,
 471                 len, NULL );
 472
 473 #elif defined( HAVE_PCNFS ) || \
 474    defined( HAVE_WINSOCK ) || defined ( __BEOS__ )
 475 /*
 476  * PCNFS (under DOS)
 477  */
 478 /*
 479  * Windows Socket API (under DOS/Windows 3.x)
 480  */
 481 /*
 482  * 32-bit Windows Socket API (under Windows NT or Windows 95)
 483  */
 484         return recv( sbiod->sbiod_sb->sb_fd, buf, len, 0 );
 485
 486 #elif defined( HAVE_NCSA )
 487 /*
 488  * NCSA Telnet TCP/IP stack (under DOS)
 489  */
 490         return nread( sbiod->sbiod_sb->sb_fd, buf, len );
 491
 492 #else
 493         return read( sbiod->sbiod_sb->sb_fd, buf, len );
 494 #endif
 495 }
 496
 497 static ber_slen_t
 498 sb_stream_write( Sockbuf_IO_Desc *sbiod, void *buf, ber_len_t len )
 499 {
 500         assert( sbiod != NULL);
 501         assert( SOCKBUF_VALID( sbiod->sbiod_sb ) );
 502
 503 #if defined(MACOS)
 504 /*
 505  * MacTCP/OpenTransport
 506  */
 507 #define MAX_WRITE       65535
 508         return tcpwrite( sbiod->sbiod_sb->sb_fd, (unsigned char *)buf,
 509                 (len<MAX_WRITE) ? len : MAX_WRITE );
 510
 511 #elif defined( HAVE_PCNFS) \
 512         || defined( HAVE_WINSOCK) || defined ( __BEOS__ )
 513 /*
 514  * PCNFS (under DOS)
 515  */
 516 /*
 517  * Windows Socket API (under DOS/Windows 3.x)
 518  */
 519 /*
 520  * 32-bit Windows Socket API (under Windows NT or Windows 95)
 521  */
 522         return send( sbiod->sbiod_sb->sb_fd, buf, len, 0 );
 523
 524 #elif defined(HAVE_NCSA)
 525         return netwrite( sbiod->sbiod_sb->sb_fd, buf, len );
 526
 527 #elif defined(VMS)
 528 /*
 529  * VMS -- each write must be 64K or smaller
 530  */
 531 #define MAX_WRITE 65535
 532         return write( sbiod->sbiod_sb->sb_fd, buf,
 533                 (len<MAX_WRITE) ? len : MAX_WRITE);
 534 #else
 535         return write( sbiod->sbiod_sb->sb_fd, buf, len );
 536 #endif
 537 }
 538
 539 static int
 540 sb_stream_close( Sockbuf_IO_Desc *sbiod )
 541 {
 542         assert( sbiod != NULL );
 543         assert( SOCKBUF_VALID( sbiod->sbiod_sb ) );
 544         tcp_close( sbiod->sbiod_sb->sb_fd );
 545    return 0;
 546 }
 547
 548 /* The argument is a pointer to the socket descriptor */
 549 static int
 550 sb_stream_setup( Sockbuf_IO_Desc *sbiod, void *arg ) {
 551         assert( sbiod != NULL );
 552
 553         if ( arg != NULL ) {
 554                 sbiod->sbiod_sb->sb_fd = *((int *)arg);
 555         }
 556         return 0;
 557 }
 558
 559 static int
 560 sb_stream_ctrl( Sockbuf_IO_Desc *sbiod, int opt, void *arg ) {
 561         /* This is an end IO descriptor */
 562         return 0;
 563 }
 564
 565 Sockbuf_IO ber_sockbuf_io_tcp = {
 566         sb_stream_setup,        /* sbi_setup */
 567         NULL,                           /* sbi_remove */
 568         sb_stream_ctrl,         /* sbi_ctrl */
 569         sb_stream_read,         /* sbi_read */
 570         sb_stream_write,        /* sbi_write */
 571         sb_stream_close         /* sbi_close */
 572 };
 573
 574
 575 /*
 576  * Support for readahead (UDP needs it)
 577  */
 578
 579 static int
 580 sb_rdahead_setup( Sockbuf_IO_Desc *sbiod, void *arg )
 581 {
 582         Sockbuf_Buf             *p;
 583
 584         assert( sbiod != NULL );
 585
 586         p = LBER_MALLOC( sizeof( *p ) );
 587         if ( p == NULL ) return -1;
 588
 589         ber_pvt_sb_buf_init( p );
 590
 591         if ( arg == NULL ) {
 592                 ber_pvt_sb_grow_buffer( p, LBER_DEFAULT_READAHEAD );
 593         } else {
 594                 ber_pvt_sb_grow_buffer( p, *((int *)arg) );
 595         }
 596
 597         sbiod->sbiod_pvt = p;
 598         return 0;
 599 }
 600
 601 static int
 602 sb_rdahead_remove( Sockbuf_IO_Desc *sbiod )
 603 {
 604         Sockbuf_Buf             *p;
 605
 606         assert( sbiod != NULL );
 607
 608         p = (Sockbuf_Buf *)sbiod->sbiod_pvt;
 609
 610         if ( p->buf_ptr != p->buf_end ) return -1;
 611
 612         ber_pvt_sb_buf_destroy( (Sockbuf_Buf *)(sbiod->sbiod_pvt) );
 613         LBER_FREE( sbiod->sbiod_pvt );
 614         sbiod->sbiod_pvt = NULL;
 615
 616         return 0;
 617 }
 618
 619 static ber_slen_t
 620 sb_rdahead_read( Sockbuf_IO_Desc *sbiod, void *buf, ber_len_t len )
 621 {
 622         Sockbuf_Buf             *p;
 623         ber_slen_t              bufptr = 0, ret, max;
 624
 625         assert( sbiod != NULL );
 626         assert( SOCKBUF_VALID( sbiod->sbiod_sb ) );
 627         assert( sbiod->sbiod_next != NULL );
 628
 629         p = (Sockbuf_Buf *)sbiod->sbiod_pvt;
 630
 631         assert( p->buf_size > 0 );
 632
 633         /* Are there anything left in the buffer? */
 634         ret = ber_pvt_sb_copy_out( p, buf, len );
 635         bufptr += ret;
 636         len -= ret;
 637
 638         if ( len == 0 ) return bufptr;
 639
 640         max = p->buf_size - p->buf_end;
 641         ret = 0;
 642         while ( max > 0 ) {
 643                 ret = LBER_SBIOD_READ_NEXT( sbiod, p->buf_base + p->buf_end,
 644                         max );
 645 #ifdef EINTR
 646                 if ( ( ret < 0 ) && ( errno == EINTR ) ) continue;
 647 #endif
 648                 break;
 649         }
 650
 651         if ( ret < 0 ) {
 652                 return ( bufptr ? bufptr : ret );
 653         }
 654
 655         p->buf_end += ret;
 656         bufptr += ber_pvt_sb_copy_out( p, (char *) buf + bufptr, len );
 657         return bufptr;
 658 }
 659
 660 static ber_slen_t
 661 sb_rdahead_write( Sockbuf_IO_Desc *sbiod, void *buf, ber_len_t len )
 662 {
 663         assert( sbiod != NULL );
 664         assert( sbiod->sbiod_next != NULL );
 665
 666         return LBER_SBIOD_WRITE_NEXT( sbiod, buf, len );
 667 }
 668
 669 static int
 670 sb_rdahead_close( Sockbuf_IO_Desc *sbiod )
 671 {
 672         assert( sbiod != NULL );
 673
 674         /* Just erase the buffer */
 675         ber_pvt_sb_buf_destroy((Sockbuf_Buf *)sbiod->sbiod_pvt);
 676         return 0;
 677 }
 678
 679 static int
 680 sb_rdahead_ctrl( Sockbuf_IO_Desc *sbiod, int opt, void *arg )
 681 {
 682         Sockbuf_Buf             *p;
 683
 684         p = (Sockbuf_Buf *)sbiod->sbiod_pvt;
 685
 686         if ( opt == LBER_SB_OPT_DATA_READY ) {
 687                 if ( p->buf_ptr != p->buf_end ) {
 688                         return 1;
 689                 }
 690
 691         } else if ( opt == LBER_SB_OPT_SET_READAHEAD ) {
 692                 if ( p->buf_size >= *((ber_len_t *)arg) ) {
 693                         return 0;
 694                 }
 695                 return ( ber_pvt_sb_grow_buffer( p, *((int *)arg) ) ?
 696                         -1 : 1 );
 697         }
 698
 699         return LBER_SBIOD_CTRL_NEXT( sbiod, opt, arg );
 700 }
 701
 702 Sockbuf_IO ber_sockbuf_io_readahead = {
 703         sb_rdahead_setup,       /* sbi_setup */
 704         sb_rdahead_remove,      /* sbi_remove */
 705         sb_rdahead_ctrl,        /* sbi_ctrl */
 706         sb_rdahead_read,        /* sbi_read */
 707         sb_rdahead_write,       /* sbi_write */
 708         sb_rdahead_close        /* sbi_close */
 709 };
 710
 711 /*
 712  * Support for simple file IO
 713  */
 714
 715 static ber_slen_t
 716 sb_fd_read( Sockbuf_IO_Desc *sbiod, void *buf, ber_len_t len )
 717 {
 718         assert( sbiod != NULL);
 719         assert( SOCKBUF_VALID( sbiod->sbiod_sb ) );
 720
 721 #ifdef LDAP_PF_LOCAL_SENDMSG
 722         if ( sbiod->sbiod_sb->sb_ungetlen ) {
 723                 ber_len_t blen = sbiod->sbiod_sb->sb_ungetlen;
 724                 if ( blen > len )
 725                         blen = len;
 726                 AC_MEMCPY( buf, sbiod->sbiod_sb->sb_ungetbuf, blen );
 727                 buf = (char *) buf + blen;
 728                 len -= blen;
 729                 sbiod->sbiod_sb->sb_ungetlen -= blen;
 730                 if ( sbiod->sbiod_sb->sb_ungetlen ) {
 731                         AC_MEMCPY( sbiod->sbiod_sb->sb_ungetbuf,
 732                                 sbiod->sbiod_sb->sb_ungetbuf+blen,
 733                                 sbiod->sbiod_sb->sb_ungetlen );
 734                 }
 735                 if ( len == 0 )
 736                         return blen;
 737         }
 738 #endif
 739         return read( sbiod->sbiod_sb->sb_fd, buf, len );
 740 }
 741
 742 static ber_slen_t
 743 sb_fd_write( Sockbuf_IO_Desc *sbiod, void *buf, ber_len_t len )
 744 {
 745         assert( sbiod != NULL);
 746         assert( SOCKBUF_VALID( sbiod->sbiod_sb ) );
 747
 748         return write( sbiod->sbiod_sb->sb_fd, buf, len );
 749 }
 750
 751 static int
 752 sb_fd_close( Sockbuf_IO_Desc *sbiod )
 753 {
 754         assert( sbiod != NULL );
 755         assert( SOCKBUF_VALID( sbiod->sbiod_sb ) );
 756
 757         close( sbiod->sbiod_sb->sb_fd );
 758         return 0;
 759 }
 760
 761 /* The argument is a pointer to the file descriptor */
 762 static int
 763 sb_fd_setup( Sockbuf_IO_Desc *sbiod, void *arg ) {
 764         assert( sbiod != NULL );
 765
 766         if ( arg != NULL )
 767                 sbiod->sbiod_sb->sb_fd = *((int *)arg);
 768         return 0;
 769 }
 770
 771 static int
 772 sb_fd_ctrl( Sockbuf_IO_Desc *sbiod, int opt, void *arg ) {
 773         /* This is an end IO descriptor */
 774         return 0;
 775 }
 776
 777 Sockbuf_IO ber_sockbuf_io_fd = {
 778         sb_fd_setup,    /* sbi_setup */
 779         NULL,                   /* sbi_remove */
 780         sb_fd_ctrl,             /* sbi_ctrl */
 781         sb_fd_read,             /* sbi_read */
 782         sb_fd_write,            /* sbi_write */
 783         sb_fd_close             /* sbi_close */
 784 };
 785
 786 /*
 787  * Debugging layer
 788  */
 789
 790 static int
 791 sb_debug_setup( Sockbuf_IO_Desc *sbiod, void *arg )
 792 {
 793         assert( sbiod != NULL );
 794
 795         if ( arg == NULL ) arg = "sockbuf_";
 796
 797         sbiod->sbiod_pvt = LBER_MALLOC( strlen( arg ) + 1 );
 798         if ( sbiod->sbiod_pvt == NULL ) return -1;
 799
 800         strcpy( (char *)sbiod->sbiod_pvt, (char *)arg );
 801         return 0;
 802 }
 803
 804 static int
 805 sb_debug_remove( Sockbuf_IO_Desc *sbiod )
 806 {
 807         assert( sbiod != NULL );
 808         assert( sbiod->sbiod_pvt != NULL );
 809
 810         LBER_FREE( sbiod->sbiod_pvt );
 811         sbiod->sbiod_pvt = NULL;
 812         return 0;
 813 }
 814
 815 static int
 816 sb_debug_ctrl( Sockbuf_IO_Desc *sbiod, int opt, void *arg )
 817 {
 818         return LBER_SBIOD_CTRL_NEXT( sbiod, opt, arg );
 819 }
 820
 821 static ber_slen_t
 822 sb_debug_read( Sockbuf_IO_Desc *sbiod, void *buf, ber_len_t len )
 823 {
 824         ber_slen_t              ret;
 825         char ebuf[128];
 826
 827         ret = LBER_SBIOD_READ_NEXT( sbiod, buf, len );
 828         if (sbiod->sbiod_sb->sb_debug & LDAP_DEBUG_PACKETS) {
 829                 int err = sock_errno();
 830                 if ( ret < 0 ) {
 831                         ber_log_printf( LDAP_DEBUG_PACKETS, sbiod->sbiod_sb->sb_debug,
 832                                 "%sread: want=%ld error=%s\n", (char *)sbiod->sbiod_pvt,
 833                                 (long)len, AC_STRERROR_R( err, ebuf, sizeof ebuf ) );
 834                 } else {
 835                         ber_log_printf( LDAP_DEBUG_PACKETS, sbiod->sbiod_sb->sb_debug,
 836                                 "%sread: want=%ld, got=%ld\n", (char *)sbiod->sbiod_pvt,
 837                                 (long)len, (long)ret );
 838                         ber_log_bprint( LDAP_DEBUG_PACKETS, sbiod->sbiod_sb->sb_debug,
 839                                 (const char *)buf, ret );
 840                 }
 841                 sock_errset(err);
 842         }
 843         return ret;
 844 }
 845
 846 static ber_slen_t
 847 sb_debug_write( Sockbuf_IO_Desc *sbiod, void *buf, ber_len_t len )
 848 {
 849         ber_slen_t              ret;
 850         char ebuf[128];
 851
 852         ret = LBER_SBIOD_WRITE_NEXT( sbiod, buf, len );
 853         if (sbiod->sbiod_sb->sb_debug & LDAP_DEBUG_PACKETS) {
 854                 int err = sock_errno();
 855                 if ( ret < 0 ) {
 856                         ber_log_printf( LDAP_DEBUG_PACKETS, sbiod->sbiod_sb->sb_debug,
 857                                 "%swrite: want=%ld error=%s\n",
 858                                 (char *)sbiod->sbiod_pvt, (long)len,
 859                                 AC_STRERROR_R( err, ebuf, sizeof ebuf ) );
 860                 } else {
 861                         ber_log_printf( LDAP_DEBUG_PACKETS, sbiod->sbiod_sb->sb_debug,
 862                                 "%swrite: want=%ld, written=%ld\n",
 863                                 (char *)sbiod->sbiod_pvt, (long)len, (long)ret );
 864                         ber_log_bprint( LDAP_DEBUG_PACKETS, sbiod->sbiod_sb->sb_debug,
 865                                 (const char *)buf, ret );
 866                 }
 867                 sock_errset(err);
 868         }
 869
 870         return ret;
 871 }
 872
 873 Sockbuf_IO ber_sockbuf_io_debug = {
 874         sb_debug_setup,         /* sbi_setup */
 875         sb_debug_remove,        /* sbi_remove */
 876         sb_debug_ctrl,          /* sbi_ctrl */
 877         sb_debug_read,          /* sbi_read */
 878         sb_debug_write,         /* sbi_write */
 879         NULL                            /* sbi_close */
 880 };
 881
 882 #ifdef LDAP_CONNECTIONLESS
 883
 884 /*
 885  * Support for UDP (CLDAP)
 886  *
 887  * All I/O at this level must be atomic. For ease of use, the sb_readahead
 888  * must be used above this module. All data reads and writes are prefixed
 889  * with a sockaddr containing the address of the remote entity. Upper levels
 890  * must read and write this sockaddr before doing the usual ber_printf/scanf
 891  * operations on LDAP messages.
 892  */
 893
 894 static int
 895 sb_dgram_setup( Sockbuf_IO_Desc *sbiod, void *arg )
 896 {
 897         assert( sbiod != NULL);
 898         assert( SOCKBUF_VALID( sbiod->sbiod_sb ) );
 899
 900         if ( arg != NULL ) sbiod->sbiod_sb->sb_fd = *((int *)arg);
 901         return 0;
 902 }
 903
 904 static ber_slen_t
 905 sb_dgram_read( Sockbuf_IO_Desc *sbiod, void *buf, ber_len_t len )
 906 {
 907         ber_slen_t rc;
 908         ber_socklen_t addrlen;
 909         struct sockaddr *src;
 910
 911         assert( sbiod != NULL );
 912         assert( SOCKBUF_VALID( sbiod->sbiod_sb ) );
 913         assert( buf != NULL );
 914
 915         addrlen = sizeof( struct sockaddr );
 916         src = buf;
 917         buf = (char *) buf + addrlen;
 918         len -= addrlen;
 919         rc = recvfrom( sbiod->sbiod_sb->sb_fd, buf, len, 0, src, &addrlen );
 920
 921         return rc > 0 ? rc+sizeof(struct sockaddr) : rc;
 922 }
 923
 924 static ber_slen_t
 925 sb_dgram_write( Sockbuf_IO_Desc *sbiod, void *buf, ber_len_t len )
 926 {
 927         ber_slen_t rc;
 928         struct sockaddr *dst;
 929
 930         assert( sbiod != NULL );
 931         assert( SOCKBUF_VALID( sbiod->sbiod_sb ) );
 932         assert( buf != NULL );
 933
 934         dst = buf;
 935         buf = (char *) buf + sizeof( struct sockaddr );
 936         len -= sizeof( struct sockaddr );
 937
 938         rc = sendto( sbiod->sbiod_sb->sb_fd, buf, len, 0, dst,
 939                 sizeof( struct sockaddr ) );
 940
 941         if ( rc < 0 ) return -1;
 942
 943         /* fake error if write was not atomic */
 944         if (rc < len) {
 945 # ifdef EMSGSIZE
 946                 errno = EMSGSIZE;
 947 # endif
 948                 return -1;
 949         }
 950         rc = len + sizeof(struct sockaddr);
 951         return rc;
 952 }
 953
 954 static int
 955 sb_dgram_close( Sockbuf_IO_Desc *sbiod )
 956 {
 957         assert( sbiod != NULL );
 958         assert( SOCKBUF_VALID( sbiod->sbiod_sb ) );
 959
 960         tcp_close( sbiod->sbiod_sb->sb_fd );
 961         return 0;
 962 }
 963
 964 static int
 965 sb_dgram_ctrl( Sockbuf_IO_Desc *sbiod, int opt, void *arg )
 966 {
 967         /* This is an end IO descriptor */
 968         return 0;
 969 }
 970
 971 Sockbuf_IO ber_sockbuf_io_udp =
 972 {
 973         sb_dgram_setup,         /* sbi_setup */
 974         NULL,                   /* sbi_remove */
 975         sb_dgram_ctrl,          /* sbi_ctrl */
 976         sb_dgram_read,          /* sbi_read */
 977         sb_dgram_write,         /* sbi_write */
 978         sb_dgram_close          /* sbi_close */
 979 };
 980
 981 #endif  /* LDAP_CONNECTIONLESS */