git.sur5r.net Git - openldap/blob - libraries/liblber/sockbuf.c

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