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

   1 /* io.c - ber general i/o routines */
   2 /*
   3  * Copyright 1998-1999 The OpenLDAP Foundation, All Rights Reserved.
   4  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
   5  */
   6 /* Portions
   7  * Copyright (c) 1990 Regents of the University of Michigan.
   8  * All rights reserved.
   9  *
  10  * Redistribution and use in source and binary forms are permitted
  11  * provided that this notice is preserved and that due credit is given
  12  * to the University of Michigan at Ann Arbor. The name of the University
  13  * may not be used to endorse or promote products derived from this
  14  * software without specific prior written permission. This software
  15  * is provided ``as is'' without express or implied warranty.
  16  */
  17
  18 #include "portable.h"
  19
  20 #include <stdio.h>
  21 #include <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
  32
  33 #include "lber-int.h"
  34
  35 static int ber_realloc LDAP_P(( BerElement *ber, unsigned long len ));
  36 static int ber_filbuf LDAP_P(( Sockbuf *sb, long len ));
  37 static long BerRead LDAP_P(( Sockbuf *sb, char *buf, long len ));
  38 #ifdef PCNFS
  39 static int BerWrite LDAP_P(( Sockbuf *sb, char *buf, long len ));
  40 #endif /* PCNFS */
  41
  42 #define bergetc( sb, len )    ( sb->sb_ber.ber_end > sb->sb_ber.ber_ptr ? \
  43                           (unsigned char)*sb->sb_ber.ber_ptr++ : \
  44                           ber_filbuf( sb, len ))
  45
  46 #ifdef MACOS
  47 /*
  48  * MacTCP/OpenTransport
  49  */
  50 #define read( s, b, l ) tcpread( s, 0, (unsigned char *)b, l, NULL )
  51 #define MAX_WRITE       65535
  52 #define BerWrite( sb, b, l )   tcpwrite( sb->sb_sd, (unsigned char *)(b), (l<MAX_WRITE)? l : MAX_WRITE )
  53 #else /* MACOS */
  54 #ifdef DOS
  55 #ifdef PCNFS
  56 /*
  57  * PCNFS (under DOS)
  58  */
  59 #define read( s, b, l ) recv( s, b, l, 0 )
  60 #define BerWrite( s, b, l ) send( s->sb_sd, b, (int) l, 0 )
  61 #endif /* PCNFS */
  62 #ifdef NCSA
  63 /*
  64  * NCSA Telnet TCP/IP stack (under DOS)
  65  */
  66 #define read( s, b, l ) nread( s, b, l )
  67 #define BerWrite( s, b, l ) netwrite( s->sb_sd, b, l )
  68 #endif /* NCSA */
  69 #ifdef WINSOCK
  70 /*
  71  * Windows Socket API (under DOS/Windows 3.x)
  72  */
  73 #define read( s, b, l ) recv( s, b, l, 0 )
  74 #define BerWrite( s, b, l ) send( s->sb_sd, b, l, 0 )
  75 #endif /* WINSOCK */
  76 #else /* DOS */
  77 #ifdef _WIN32
  78 /*
  79  * 32-bit Windows Socket API (under Windows NT or Windows 95)
  80  */
  81 #define read( s, b, l )         recv( s, b, l, 0 )
  82 #define BerWrite( s, b, l )     send( s->sb_sd, b, l, 0 )
  83 #else /* _WIN32 */
  84 #ifdef VMS
  85 /*
  86  * VMS -- each write must be 64K or smaller
  87  */
  88 #define MAX_WRITE 65535
  89 #define BerWrite( sb, b, l ) write( sb->sb_sd, b, (l<MAX_WRITE)? l : MAX_WRITE)
  90 #else /* VMS */
  91 /*
  92  * everything else (Unix/BSD 4.3 socket API)
  93  */
  94 #define BerWrite( sb, b, l )    write( sb->sb_sd, b, l )
  95 #endif /* VMS */
  96 #define udp_read( sb, b, l, al ) recvfrom(sb->sb_sd, (char *)b, l, 0, \
  97                 (struct sockaddr *)sb->sb_fromaddr, \
  98                 (al = sizeof(struct sockaddr), &al))
  99 #define udp_write( sb, b, l ) sendto(sb->sb_sd, (char *)(b), l, 0, \
 100                 (struct sockaddr *)sb->sb_useaddr, sizeof(struct sockaddr))
 101 #endif /* _WIN32 */
 102 #endif /* DOS */
 103 #endif /* MACOS */
 104
 105 #ifndef udp_read
 106 #define udp_read( sb, b, l, al )        CLDAP NOT SUPPORTED
 107 #define udp_write( sb, b, l )           CLDAP NOT SUPPORTED
 108 #endif /* udp_read */
 109
 110 #define EXBUFSIZ        1024
 111
 112 static int
 113 ber_filbuf( Sockbuf *sb, long len )
 114 {
 115         short   rc;
 116 #ifdef LDAP_CONNECTIONLESS
 117         int     addrlen;
 118 #endif /* LDAP_CONNECTIONLESS */
 119
 120         if ( sb->sb_ber.ber_buf == NULL ) {
 121                 if ( (sb->sb_ber.ber_buf = (char *) malloc( READBUFSIZ )) ==
 122                     NULL )
 123                         return( -1 );
 124                 sb->sb_ber.ber_ptr = sb->sb_ber.ber_buf;
 125                 sb->sb_ber.ber_end = sb->sb_ber.ber_buf;
 126         }
 127
 128         if ( sb->sb_naddr > 0 ) {
 129 #ifdef LDAP_CONNECTIONLESS
 130                 rc = udp_read(sb, sb->sb_ber.ber_buf, READBUFSIZ, addrlen );
 131
 132                 if ( sb->sb_debug ) {
 133                         lber_log_printf( LDAP_DEBUG_ANY, sb->sb_debug,
 134                                 "ber_filbuf udp_read %d bytes\n",
 135                                         rc );
 136                         if ( rc > 0 )
 137                                 lber_log_bprint( LDAP_DEBUG_PACKETS, sb->sb_debug,
 138                                         sb->sb_ber.ber_buf, rc );
 139                 }
 140 #else /* LDAP_CONNECTIONLESS */
 141                 rc = -1;
 142 #endif /* LDAP_CONNECTIONLESS */
 143         } else {
 144                 rc = read( sb->sb_sd, sb->sb_ber.ber_buf,
 145                         ((sb->sb_options & LBER_NO_READ_AHEAD) && (len < READBUFSIZ)) ?
 146                                 len : READBUFSIZ );
 147         }
 148
 149         if ( rc > 0 ) {
 150                 sb->sb_ber.ber_ptr = sb->sb_ber.ber_buf + 1;
 151                 sb->sb_ber.ber_end = sb->sb_ber.ber_buf + rc;
 152                 return( (unsigned char)*sb->sb_ber.ber_buf );
 153         }
 154
 155         return( -1 );
 156 }
 157
 158
 159 static long
 160 BerRead( Sockbuf *sb, char *buf, long len )
 161 {
 162         int     c;
 163         long    nread = 0;
 164
 165         while ( len > 0 ) {
 166                 if ( (c = bergetc( sb, len )) < 0 ) {
 167                         if ( nread > 0 )
 168                                 break;
 169                         return( c );
 170                 }
 171                 *buf++ = (char) c;
 172                 nread++;
 173                 len--;
 174         }
 175
 176         return( nread );
 177 }
 178
 179
 180 long
 181 ber_read( BerElement *ber, char *buf, unsigned long len )
 182 {
 183         unsigned long   actuallen, nleft;
 184
 185         nleft = ber->ber_end - ber->ber_ptr;
 186         actuallen = nleft < len ? nleft : len;
 187
 188         SAFEMEMCPY( buf, ber->ber_ptr, (size_t)actuallen );
 189
 190         ber->ber_ptr += actuallen;
 191
 192         return( (long)actuallen );
 193 }
 194
 195 long
 196 ber_write( BerElement *ber, char *buf, unsigned long len, int nosos )
 197 {
 198         if ( nosos || ber->ber_sos == NULL ) {
 199                 if ( ber->ber_ptr + len > ber->ber_end ) {
 200                         if ( ber_realloc( ber, len ) != 0 )
 201                                 return( -1 );
 202                 }
 203                 SAFEMEMCPY( ber->ber_ptr, buf, (size_t)len );
 204                 ber->ber_ptr += len;
 205                 return( len );
 206         } else {
 207                 if ( ber->ber_sos->sos_ptr + len > ber->ber_end ) {
 208                         if ( ber_realloc( ber, len ) != 0 )
 209                                 return( -1 );
 210                 }
 211                 SAFEMEMCPY( ber->ber_sos->sos_ptr, buf, (size_t)len );
 212                 ber->ber_sos->sos_ptr += len;
 213                 ber->ber_sos->sos_clen += len;
 214                 return( len );
 215         }
 216 }
 217
 218 static int
 219 ber_realloc( BerElement *ber, unsigned long len )
 220 {
 221         unsigned long   need, have, total;
 222         Seqorset        *s;
 223         long            off;
 224         char            *oldbuf;
 225
 226         have = (ber->ber_end - ber->ber_buf) / EXBUFSIZ;
 227         need = (len < EXBUFSIZ ? 1 : (len + (EXBUFSIZ - 1)) / EXBUFSIZ);
 228         total = have * EXBUFSIZ + need * EXBUFSIZ;
 229
 230         oldbuf = ber->ber_buf;
 231
 232         if ( ber->ber_buf == NULL ) {
 233                 if ( (ber->ber_buf = (char *) malloc( (size_t)total )) == NULL )
 234                         return( -1 );
 235         } else if ( (ber->ber_buf = (char *) realloc( ber->ber_buf,
 236             (size_t)total )) == NULL )
 237                 return( -1 );
 238
 239         ber->ber_end = ber->ber_buf + total;
 240
 241         /*
 242          * If the stinking thing was moved, we need to go through and
 243          * reset all the sos and ber pointers.  Offsets would've been
 244          * a better idea... oh well.
 245          */
 246
 247         if ( ber->ber_buf != oldbuf ) {
 248                 ber->ber_ptr = ber->ber_buf + (ber->ber_ptr - oldbuf);
 249
 250                 for ( s = ber->ber_sos; s != NULLSEQORSET; s = s->sos_next ) {
 251                         off = s->sos_first - oldbuf;
 252                         s->sos_first = ber->ber_buf + off;
 253
 254                         off = s->sos_ptr - oldbuf;
 255                         s->sos_ptr = ber->ber_buf + off;
 256                 }
 257         }
 258
 259         return( 0 );
 260 }
 261
 262 void
 263 ber_free( BerElement *ber, int freebuf )
 264 {
 265         if ( freebuf && ber->ber_buf != NULL )
 266                 free( ber->ber_buf );
 267         ber->ber_buf = NULL;
 268         free( (char *) ber );
 269 }
 270
 271 int
 272 ber_flush( Sockbuf *sb, BerElement *ber, int freeit )
 273 {
 274         long    nwritten, towrite, rc;
 275
 276         if ( ber->ber_rwptr == NULL ) {
 277                 ber->ber_rwptr = ber->ber_buf;
 278         }
 279         towrite = ber->ber_ptr - ber->ber_rwptr;
 280
 281         if ( sb->sb_debug ) {
 282                 lber_log_printf( LDAP_DEBUG_ANY, sb->sb_debug,
 283                         "ber_flush: %ld bytes to sd %ld%s\n", towrite,
 284                     (long) sb->sb_sd, ber->ber_rwptr != ber->ber_buf ? " (re-flush)"
 285                     : "" );
 286                 lber_log_bprint( LDAP_DEBUG_PACKETS, sb->sb_debug,
 287                         ber->ber_rwptr, towrite );
 288         }
 289
 290 #if !defined(MACOS) && !defined(DOS)
 291         if ( sb->sb_options & (LBER_TO_FILE | LBER_TO_FILE_ONLY) ) {
 292                 rc = write( sb->sb_fd, ber->ber_buf, towrite );
 293                 if ( sb->sb_options & LBER_TO_FILE_ONLY ) {
 294                         return( (int)rc );
 295                 }
 296         }
 297 #endif
 298
 299         nwritten = 0;
 300         do {
 301                 if (sb->sb_naddr > 0) {
 302 #ifdef LDAP_CONNECTIONLESS
 303                         rc = udp_write( sb, ber->ber_buf + nwritten,
 304                             (size_t)towrite );
 305 #else /* LDAP_CONNECTIONLESS */
 306                         rc = -1;
 307 #endif /* LDAP_CONNECTIONLESS */
 308                         if ( rc <= 0 )
 309                                 return( -1 );
 310
 311                         /* fake error if write was not atomic */
 312                         if (rc < towrite) {
 313 #ifdef EMSGSIZE
 314                             errno = EMSGSIZE;
 315 #endif
 316                             return( -1 );
 317                         }
 318                 } else {
 319                         if ( (rc = BerWrite( sb, ber->ber_rwptr,
 320                             (size_t) towrite )) <= 0 ) {
 321                                 return( -1 );
 322                         }
 323                 }
 324                 towrite -= rc;
 325                 nwritten += rc;
 326                 ber->ber_rwptr += rc;
 327         } while ( towrite > 0 );
 328
 329         if ( freeit )
 330                 ber_free( ber, 1 );
 331
 332         return( 0 );
 333 }
 334
 335 BerElement *
 336 ber_alloc_t( int options )
 337 {
 338         BerElement      *ber;
 339
 340         if ( (ber = (BerElement *) calloc( 1, sizeof(BerElement) )) == NULLBER )
 341                 return( NULLBER );
 342         ber->ber_tag = LBER_DEFAULT;
 343         ber->ber_options = options;
 344         ber->ber_debug = lber_int_debug;
 345
 346         return( ber );
 347 }
 348
 349 BerElement *
 350 ber_alloc( void )
 351 {
 352         return( ber_alloc_t( 0 ) );
 353 }
 354
 355 BerElement *
 356 der_alloc( void )
 357 {
 358         return( ber_alloc_t( LBER_USE_DER ) );
 359 }
 360
 361 BerElement *
 362 ber_dup( BerElement *ber )
 363 {
 364         BerElement      *new;
 365
 366         if ( (new = ber_alloc()) == NULLBER )
 367                 return( NULLBER );
 368
 369         *new = *ber;
 370
 371         return( new );
 372 }
 373
 374
 375 /* OLD U-Mich ber_init() */
 376 void
 377 ber_init_w_nullc( BerElement *ber, int options )
 378 {
 379         (void) memset( (char *)ber, '\0', sizeof( BerElement ));
 380         ber->ber_tag = LBER_DEFAULT;
 381         ber->ber_options = (char) options;
 382 }
 383
 384 /* New C-API ber_init() */
 385 /* This function constructs a BerElement containing a copy
 386 ** of the data in the bv argument.
 387 */
 388 BerElement *
 389 ber_init( struct berval *bv )
 390 {
 391         BerElement *ber;
 392
 393         if ( bv == NULL ) {
 394                 return NULL;
 395         }
 396
 397         ber = ber_alloc_t( 0 );
 398
 399         if( ber == NULLBER ) {
 400                 /* allocation failed */
 401                 return ( NULL );
 402         }
 403
 404         /* copy the data */
 405         if ( (ber_write ( ber, bv->bv_val, bv->bv_len, 0 )) != bv->bv_len ) {
 406                 /* write failed, so free and return NULL */
 407                 ber_free( ber, 1 );
 408                 return( NULL );
 409         }
 410
 411         ber_reset( ber, 1 );    /* reset the pointer to the start of the buffer */
 412
 413         return ( ber );
 414 }
 415
 416 /* New C-API ber_flatten routine */
 417 /* This routine allocates a struct berval whose contents are a BER
 418 ** encoding taken from the ber argument.  The bvPtr pointer pointers to
 419 ** the returned berval.
 420 */
 421 int ber_flatten(
 422         BerElement *ber,
 423         struct berval **bvPtr)
 424 {
 425         struct berval *bv;
 426
 427         if(bvPtr == NULL) {
 428                 return( -1 );
 429         }
 430
 431         if ( (bv = malloc( sizeof(struct berval))) == NULL ) {
 432                 return( -1 );
 433         }
 434
 435         if ( ber == NULL ) {
 436                 /* ber is null, create an empty berval */
 437                 bv->bv_val = NULL;
 438                 bv->bv_len = 0;
 439
 440         } else {
 441                 /* copy the berval */
 442                 ptrdiff_t len = ber->ber_ptr - ber->ber_buf;
 443
 444                 if ( (bv->bv_val = (char *) malloc( len + 1 )) == NULL ) {
 445                         ber_bvfree( bv );
 446                         return( -1 );
 447                 }
 448
 449                 SAFEMEMCPY( bv->bv_val, ber->ber_buf, (size_t)len );
 450                 bv->bv_val[len] = '\0';
 451                 bv->bv_len = len;
 452         }
 453
 454         *bvPtr = bv;
 455         return( 0 );
 456 }
 457
 458 void
 459 ber_reset( BerElement *ber, int was_writing )
 460 {
 461         if ( was_writing ) {
 462                 ber->ber_end = ber->ber_ptr;
 463                 ber->ber_ptr = ber->ber_buf;
 464         } else {
 465                 ber->ber_ptr = ber->ber_end;
 466         }
 467
 468         ber->ber_rwptr = NULL;
 469 }
 470
 471 /* return the tag - LBER_DEFAULT returned means trouble */
 472 static unsigned long
 473 get_tag( Sockbuf *sb )
 474 {
 475         unsigned char   xbyte;
 476         unsigned long   tag;
 477         char            *tagp;
 478         unsigned int    i;
 479
 480         if ( BerRead( sb, (char *) &xbyte, 1 ) != 1 )
 481                 return( LBER_DEFAULT );
 482
 483         if ( (xbyte & LBER_BIG_TAG_MASK) != LBER_BIG_TAG_MASK )
 484                 return( (unsigned long) xbyte );
 485
 486         tagp = (char *) &tag;
 487         tagp[0] = xbyte;
 488         for ( i = 1; i < sizeof(long); i++ ) {
 489                 if ( BerRead( sb, (char *) &xbyte, 1 ) != 1 )
 490                         return( LBER_DEFAULT );
 491
 492                 tagp[i] = xbyte;
 493
 494                 if ( ! (xbyte & LBER_MORE_TAG_MASK) )
 495                         break;
 496         }
 497
 498         /* tag too big! */
 499         if ( i == sizeof(long) )
 500                 return( LBER_DEFAULT );
 501
 502         /* want leading, not trailing 0's */
 503         return( tag >> (sizeof(long) - i - 1) );
 504 }
 505
 506 unsigned long
 507 ber_get_next( Sockbuf *sb, unsigned long *len, BerElement *ber )
 508 {
 509         unsigned long   tag = 0, netlen, toread;
 510         unsigned char   lc;
 511         long            rc;
 512         long            noctets;
 513         unsigned int    diff;
 514
 515         if ( ber->ber_debug ) {
 516                 lber_log_printf( LDAP_DEBUG_TRACE, ber->ber_debug,
 517                         "ber_get_next\n" );
 518         }
 519
 520         /*
 521          * Any ber element looks like this: tag length contents.
 522          * Assuming everything's ok, we return the tag byte (we
 523          * can assume a single byte), return the length in len,
 524          * and the rest of the undecoded element in buf.
 525          *
 526          * Assumptions:
 527          *      1) small tags (less than 128)
 528          *      2) definite lengths
 529          *      3) primitive encodings used whenever possible
 530          */
 531
 532         /*
 533          * first time through - malloc the buffer, set up ptrs, and
 534          * read the tag and the length and as much of the rest as we can
 535          */
 536
 537         if ( ber->ber_rwptr == NULL ) {
 538                 /*
 539                  * First, we read the tag.
 540                  */
 541
 542                 if ( (tag = get_tag( sb )) == LBER_DEFAULT ) {
 543                         return( LBER_DEFAULT );
 544                 }
 545                 ber->ber_tag = tag;
 546
 547                 /*
 548                  * Next, read the length.  The first byte contains the length
 549                  * of the length.  If bit 8 is set, the length is the long
 550                  * form, otherwise it's the short form.  We don't allow a
 551                  * length that's greater than what we can hold in an unsigned
 552                  * long.
 553                  */
 554
 555                 *len = netlen = 0;
 556                 if ( BerRead( sb, (char *) &lc, 1 ) != 1 ) {
 557                         return( LBER_DEFAULT );
 558                 }
 559                 if ( lc & 0x80 ) {
 560                         noctets = (lc & 0x7f);
 561                         if ( noctets > sizeof(unsigned long) )
 562                                 return( LBER_DEFAULT );
 563                         diff = sizeof(unsigned long) - noctets;
 564                         if ( BerRead( sb, (char *) &netlen + diff, noctets ) !=
 565                             noctets ) {
 566                                 return( LBER_DEFAULT );
 567                         }
 568                         *len = AC_NTOHL( netlen );
 569                 } else {
 570                         *len = lc;
 571                 }
 572                 ber->ber_len = *len;
 573
 574                 /*
 575                  * Finally, malloc a buffer for the contents and read it in.
 576                  * It's this buffer that's passed to all the other ber decoding
 577                  * routines.
 578                  */
 579
 580 #if defined( DOS ) && !defined( _WIN32 )
 581                 if ( *len > 65535 ) {   /* DOS can't allocate > 64K */
 582                     return( LBER_DEFAULT );
 583                 }
 584 #endif /* DOS && !_WIN32 */
 585
 586                 if ( ( sb->sb_options & LBER_MAX_INCOMING_SIZE ) &&
 587                     *len > (unsigned long) sb->sb_max_incoming ) {
 588                         return( LBER_DEFAULT );
 589                 }
 590
 591                 if ( (ber->ber_buf = (char *) malloc( (size_t)*len )) == NULL ) {
 592                         return( LBER_DEFAULT );
 593                 }
 594                 ber->ber_ptr = ber->ber_buf;
 595                 ber->ber_end = ber->ber_buf + *len;
 596                 ber->ber_rwptr = ber->ber_buf;
 597         }
 598
 599         toread = (unsigned long)ber->ber_end - (unsigned long)ber->ber_rwptr;
 600         do {
 601                 if ( (rc = BerRead( sb, ber->ber_rwptr, (long)toread )) <= 0 ) {
 602                         return( LBER_DEFAULT );
 603                 }
 604
 605                 toread -= rc;
 606                 ber->ber_rwptr += rc;
 607         } while ( toread > 0 );
 608
 609         if ( ber->ber_debug ) {
 610                 lber_log_printf( LDAP_DEBUG_TRACE, ber->ber_debug,
 611                         "ber_get_next: tag 0x%lx len %ld contents:\n",
 612                     tag, ber->ber_len );
 613
 614                 lber_log_dump( LDAP_DEBUG_BER, ber->ber_debug, ber, 1 );
 615         }
 616
 617         *len = ber->ber_len;
 618         ber->ber_rwptr = NULL;
 619         return( ber->ber_tag );
 620 }
 621
 622 Sockbuf *lber_sockbuf_alloc( void )
 623 {
 624         Sockbuf *sb = calloc(1, sizeof(Sockbuf));
 625         sb->sb_debug = lber_int_debug;
 626         return sb;
 627 }
 628
 629 Sockbuf *lber_sockbuf_alloc_fd( int fd )
 630 {
 631         Sockbuf *sb = lber_sockbuf_alloc();
 632         sb->sb_sd = fd;
 633
 634         return sb;
 635 }
 636
 637 void lber_sockbuf_free( Sockbuf *sb )
 638 {
 639         if(sb == NULL) return;
 640
 641         free(sb);
 642 }
 643
 644 int lber_sockbuf_get_option( Sockbuf *sb, int opt, void *outvalue )
 645 {
 646         return LBER_OPT_ERROR;
 647 }
 648
 649 int lber_sockbuf_set_option( Sockbuf *sb, int opt, void *invalue )
 650 {
 651         return LBER_OPT_ERROR;
 652 }