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
  22 #include <ac/stdlib.h>
  23
  24 #include <ac/ctype.h>
  25 #include <ac/errno.h>
  26 #include <ac/socket.h>
  27 #include <ac/string.h>
  28 #include <ac/unistd.h>
  29
  30 #ifdef HAVE_IO_H
  31 #include <io.h>
  32 #endif
  33
  34 #undef LDAP_F_PRE
  35 #define LDAP_F_PRE LDAP_F_EXPORT
  36
  37 #include "lber-int.h"
  38
  39 static ber_slen_t BerRead LDAP_P((
  40         Sockbuf *sb,
  41         char *buf,
  42         ber_len_t len ));
  43
  44 static int ber_realloc LDAP_P((
  45         BerElement *ber,
  46         ber_len_t len ));
  47
  48 #define EXBUFSIZ        1024
  49
  50 /* probably far too large... */
  51 #define MAX_BERBUFSIZE  (128*1024)
  52
  53 #if defined( DOS ) && !defined( _WIN32 ) && (MAX_BERBUFSIZE > 65535)
  54 # undef MAX_BERBUFSIZE
  55 # define MAX_BERBUFSIZE 65535
  56 #endif
  57
  58 static ber_slen_t
  59 BerRead(
  60         Sockbuf *sb,
  61         char *buf,
  62         ber_len_t len )
  63 {
  64         ber_slen_t      c;
  65         ber_slen_t      nread = 0;
  66
  67         assert( sb != NULL );
  68         assert( buf != NULL );
  69
  70         assert( SOCKBUF_VALID( sb ) );
  71
  72         while ( len > 0 ) {
  73                 if ( (c = ber_pvt_sb_read( sb, buf, len )) <= 0 ) {
  74                         if ( nread > 0 )
  75                                 break;
  76                         return( c );
  77                 }
  78                 buf+= c;
  79                 nread+=c;
  80                 len-=c;
  81         }
  82
  83         return( nread );
  84 }
  85
  86 ber_slen_t
  87 ber_read(
  88         BerElement *ber,
  89         char *buf,
  90         ber_len_t len )
  91 {
  92         ber_len_t       actuallen, nleft;
  93
  94         assert( ber != NULL );
  95         assert( buf != NULL );
  96
  97         assert( BER_VALID( ber ) );
  98
  99         nleft = ber->ber_end - ber->ber_ptr;
 100         actuallen = nleft < len ? nleft : len;
 101
 102         SAFEMEMCPY( buf, ber->ber_ptr, actuallen );
 103
 104         ber->ber_ptr += actuallen;
 105
 106         return( (ber_slen_t) actuallen );
 107 }
 108
 109 ber_slen_t
 110 ber_write(
 111         BerElement *ber,
 112         LDAP_CONST char *buf,
 113         ber_len_t len,
 114         int nosos )
 115 {
 116         assert( ber != NULL );
 117         assert( buf != NULL );
 118
 119         assert( BER_VALID( ber ) );
 120
 121         if ( nosos || ber->ber_sos == NULL ) {
 122                 if ( ber->ber_ptr + len > ber->ber_end ) {
 123                         if ( ber_realloc( ber, len ) != 0 )
 124                                 return( -1 );
 125                 }
 126                 SAFEMEMCPY( ber->ber_ptr, buf, (size_t)len );
 127                 ber->ber_ptr += len;
 128                 return( (ber_slen_t) len );
 129
 130         } else {
 131                 if ( ber->ber_sos->sos_ptr + len > ber->ber_end ) {
 132                         if ( ber_realloc( ber, len ) != 0 )
 133                                 return( -1 );
 134                 }
 135                 SAFEMEMCPY( ber->ber_sos->sos_ptr, buf, (size_t)len );
 136                 ber->ber_sos->sos_ptr += len;
 137                 ber->ber_sos->sos_clen += len;
 138                 return( (ber_slen_t) len );
 139         }
 140 }
 141
 142 static int
 143 ber_realloc( BerElement *ber, ber_len_t len )
 144 {
 145         ber_len_t       need, have, total;
 146         Seqorset        *s;
 147         long            off;
 148         char            *oldbuf;
 149
 150         assert( ber != NULL );
 151         assert( len > 0 );
 152
 153         assert( BER_VALID( ber ) );
 154
 155         have = (ber->ber_end - ber->ber_buf) / EXBUFSIZ;
 156         need = (len < EXBUFSIZ ? 1 : (len + (EXBUFSIZ - 1)) / EXBUFSIZ);
 157         total = have * EXBUFSIZ + need * EXBUFSIZ;
 158
 159         oldbuf = ber->ber_buf;
 160
 161         ber->ber_buf = (char *) LBER_REALLOC( ber->ber_buf, total );
 162
 163         if ( ber->ber_buf == NULL ) {
 164                 ber->ber_buf = oldbuf;
 165                 return( -1 );
 166         }
 167
 168         ber->ber_end = ber->ber_buf + total;
 169
 170         /*
 171          * If the stinking thing was moved, we need to go through and
 172          * reset all the sos and ber pointers.  Offsets would've been
 173          * a better idea... oh well.
 174          */
 175
 176         if ( ber->ber_buf != oldbuf ) {
 177                 ber->ber_ptr = ber->ber_buf + (ber->ber_ptr - oldbuf);
 178
 179                 for ( s = ber->ber_sos; s != NULL; s = s->sos_next ) {
 180                         off = s->sos_first - oldbuf;
 181                         s->sos_first = ber->ber_buf + off;
 182
 183                         off = s->sos_ptr - oldbuf;
 184                         s->sos_ptr = ber->ber_buf + off;
 185                 }
 186         }
 187
 188         return( 0 );
 189 }
 190
 191 void
 192 ber_free( BerElement *ber, int freebuf )
 193 {
 194 #ifdef LDAP_MEMORY_DEBUG
 195         assert( ber != NULL );
 196 #endif
 197
 198         if( ber == NULL ) {
 199                 return;
 200         }
 201
 202         assert( BER_VALID( ber ) );
 203
 204         if ( freebuf && ber->ber_buf != NULL )
 205                 LBER_FREE( ber->ber_buf );
 206
 207         ber->ber_buf = NULL;
 208         ber->ber_valid = LBER_UNINITIALIZED;
 209
 210         LBER_FREE( (char *) ber );
 211 }
 212
 213 int
 214 ber_flush( Sockbuf *sb, BerElement *ber, int freeit )
 215 {
 216         ber_len_t       nwritten, towrite;
 217         ber_slen_t      rc;
 218
 219         assert( sb != NULL );
 220         assert( ber != NULL );
 221
 222         assert( SOCKBUF_VALID( ber ) );
 223         assert( BER_VALID( ber ) );
 224
 225         if ( ber->ber_rwptr == NULL ) {
 226                 ber->ber_rwptr = ber->ber_buf;
 227         }
 228         towrite = ber->ber_ptr - ber->ber_rwptr;
 229
 230         if ( sb->sb_debug ) {
 231                 ber_log_printf( LDAP_DEBUG_ANY, sb->sb_debug,
 232                         "ber_flush: %ld bytes to sd %ld%s\n", towrite,
 233                     (long) sb->sb_sd, ber->ber_rwptr != ber->ber_buf ? " (re-flush)"
 234                     : "" );
 235                 ber_log_bprint( LDAP_DEBUG_PACKETS, sb->sb_debug,
 236                         ber->ber_rwptr, towrite );
 237         }
 238
 239 #if HAVE_WRITE
 240         if ( sb->sb_options & (LBER_TO_FILE | LBER_TO_FILE_ONLY) ) {
 241                 rc = write( sb->sb_fd, ber->ber_rwptr, towrite );
 242                 if ( sb->sb_options & LBER_TO_FILE_ONLY ) {
 243                         if ( freeit )
 244                                 ber_free( ber, 1 );
 245                         return( (int)rc );
 246                 }
 247         }
 248 #endif
 249
 250         nwritten = 0;
 251         do {
 252                 rc = ber_pvt_sb_write( sb, ber->ber_rwptr, towrite );
 253                 if (rc<=0) {
 254                         return -1;
 255                 }
 256                 towrite -= rc;
 257                 nwritten += rc;
 258                 ber->ber_rwptr += rc;
 259         } while ( towrite > 0 );
 260
 261         if ( freeit )
 262                 ber_free( ber, 1 );
 263
 264         return( 0 );
 265 }
 266
 267 BerElement *
 268 ber_alloc_t( int options )
 269 {
 270         BerElement      *ber;
 271
 272     ber_int_options.lbo_valid = LBER_INITIALIZED;
 273
 274         ber = (BerElement *) LBER_CALLOC( 1, sizeof(BerElement) );
 275
 276         if ( ber == NULL )
 277                 return( NULL );
 278
 279         ber->ber_valid = LBER_VALID_BERELEMENT;
 280         ber->ber_tag = LBER_DEFAULT;
 281         ber->ber_options = options;
 282         ber->ber_debug = ber_int_debug;
 283
 284         assert( BER_VALID( ber ) );
 285         return( ber );
 286 }
 287
 288 BerElement *
 289 ber_alloc( void )       /* deprecated */
 290 {
 291         return( ber_alloc_t( 0 ) );
 292 }
 293
 294 BerElement *
 295 der_alloc( void )       /* deprecated */
 296 {
 297         return( ber_alloc_t( LBER_USE_DER ) );
 298 }
 299
 300 BerElement *
 301 ber_dup( LDAP_CONST BerElement *ber )
 302 {
 303         BerElement      *new;
 304
 305         assert( ber != NULL );
 306         assert( BER_VALID( ber ) );
 307
 308         if ( (new = ber_alloc_t( ber->ber_options )) == NULL ) {
 309                 return( NULL );
 310         }
 311
 312         *new = *ber;
 313
 314         assert( BER_VALID( new ) );
 315         return( new );
 316 }
 317
 318
 319 /* OLD U-Mich ber_init() */
 320 void
 321 ber_init_w_nullc( BerElement *ber, int options )
 322 {
 323         assert( ber != NULL );
 324
 325     ber_int_options.lbo_valid = LBER_INITIALIZED;
 326
 327         (void) memset( (char *)ber, '\0', sizeof( BerElement ));
 328         ber->ber_valid = LBER_VALID_BERELEMENT;
 329         ber->ber_tag = LBER_DEFAULT;
 330         ber->ber_options = (char) options;
 331         ber->ber_debug = ber_int_debug;
 332
 333         assert( BER_VALID( ber ) );
 334 }
 335
 336 /* New C-API ber_init() */
 337 /* This function constructs a BerElement containing a copy
 338 ** of the data in the bv argument.
 339 */
 340 BerElement *
 341 ber_init( struct berval *bv )
 342 {
 343         BerElement *ber;
 344
 345         assert( bv != NULL );
 346
 347     ber_int_options.lbo_valid = LBER_INITIALIZED;
 348
 349         if ( bv == NULL ) {
 350                 return NULL;
 351         }
 352
 353         ber = ber_alloc_t( 0 );
 354
 355         if( ber == NULL ) {
 356                 /* allocation failed */
 357                 return ( NULL );
 358         }
 359
 360         /* copy the data */
 361         if ( ( (ber_len_t) ber_write ( ber, bv->bv_val, bv->bv_len, 0 )) != bv->bv_len ) {
 362                 /* write failed, so free and return NULL */
 363                 ber_free( ber, 1 );
 364                 return( NULL );
 365         }
 366
 367         ber_reset( ber, 1 );    /* reset the pointer to the start of the buffer */
 368
 369         return ( ber );
 370 }
 371
 372 /* New C-API ber_flatten routine */
 373 /* This routine allocates a struct berval whose contents are a BER
 374 ** encoding taken from the ber argument.  The bvPtr pointer pointers to
 375 ** the returned berval.
 376 */
 377 int ber_flatten(
 378         LDAP_CONST BerElement *ber,
 379         struct berval **bvPtr)
 380 {
 381         struct berval *bv;
 382
 383         assert( bvPtr != NULL );
 384
 385     ber_int_options.lbo_valid = LBER_INITIALIZED;
 386
 387         if(bvPtr == NULL) {
 388                 return( -1 );
 389         }
 390
 391         if ( (bv = LBER_MALLOC( sizeof(struct berval))) == NULL ) {
 392                 return( -1 );
 393         }
 394
 395         if ( ber == NULL ) {
 396                 /* ber is null, create an empty berval */
 397                 bv->bv_val = NULL;
 398                 bv->bv_len = 0;
 399
 400         } else {
 401                 /* copy the berval */
 402                 ber_len_t len = ber->ber_ptr - ber->ber_buf;
 403
 404                 if ( (bv->bv_val = (char *) LBER_MALLOC( len + 1 )) == NULL ) {
 405                         ber_bvfree( bv );
 406                         return( -1 );
 407                 }
 408
 409                 SAFEMEMCPY( bv->bv_val, ber->ber_buf, len );
 410                 bv->bv_val[len] = '\0';
 411                 bv->bv_len = len;
 412         }
 413
 414         *bvPtr = bv;
 415         return( 0 );
 416 }
 417
 418 void
 419 ber_reset( BerElement *ber, int was_writing )
 420 {
 421         assert( ber != NULL );
 422         assert( BER_VALID( ber ) );
 423
 424         if ( was_writing ) {
 425                 ber->ber_end = ber->ber_ptr;
 426                 ber->ber_ptr = ber->ber_buf;
 427         } else {
 428                 ber->ber_ptr = ber->ber_end;
 429         }
 430
 431         ber->ber_rwptr = NULL;
 432 }
 433
 434 #if 0
 435 /* return the tag - LBER_DEFAULT returned means trouble */
 436 static ber_tag_t
 437 get_tag( Sockbuf *sb )
 438 {
 439         unsigned char   xbyte;
 440         ber_tag_t       tag;
 441         char            *tagp;
 442         unsigned int    i;
 443
 444         assert( sb != NULL );
 445         assert( SOCKBUF_VALID( sb ) );
 446
 447         if ( ber_pvt_sb_read( sb, (char *) &xbyte, 1 ) != 1 )
 448                 return( LBER_DEFAULT );
 449
 450         if ( (xbyte & LBER_BIG_TAG_MASK) != LBER_BIG_TAG_MASK )
 451                 return( (ber_tag_t) xbyte );
 452
 453         tagp = (char *) &tag;
 454         tagp[0] = xbyte;
 455         for ( i = 1; i < sizeof(ber_tag_t); i++ ) {
 456                 if ( ber_pvt_sb_read( sb, (char *) &xbyte, 1 ) != 1 )
 457                         return( LBER_DEFAULT );
 458
 459                 tagp[i] = xbyte;
 460
 461                 if ( ! (xbyte & LBER_MORE_TAG_MASK) )
 462                         break;
 463         }
 464
 465         /* tag too big! */
 466         if ( i == sizeof(ber_tag_t) )
 467                 return( LBER_DEFAULT );
 468
 469         /* want leading, not trailing 0's */
 470         return( tag >> (sizeof(ber_tag_t) - i - 1) );
 471 }
 472 #endif
 473
 474 /*
 475  * A rewrite of ber_get_next that can safely be called multiple times
 476  * for the same packet. It will simply continue were it stopped until
 477  * a full packet is read.
 478  */
 479
 480 ber_tag_t
 481 ber_get_next(
 482         Sockbuf *sb,
 483         ber_len_t *len,
 484         BerElement *ber )
 485 {
 486         assert( sb != NULL );
 487         assert( len != NULL );
 488         assert( ber != NULL );
 489
 490         assert( SOCKBUF_VALID( sb ) );
 491         assert( BER_VALID( ber ) );
 492
 493         ber_log_printf( LDAP_DEBUG_TRACE, ber->ber_debug,
 494                 "ber_get_next\n" );
 495
 496         /*
 497          * Any ber element looks like this: tag length contents.
 498          * Assuming everything's ok, we return the tag byte (we
 499          * can assume a single byte), return the length in len,
 500          * and the rest of the undecoded element in buf.
 501          *
 502          * Assumptions:
 503          *      1) small tags (less than 128)
 504          *      2) definite lengths
 505          *      3) primitive encodings used whenever possible
 506          */
 507
 508         if (ber->ber_rwptr == NULL) {
 509                 /* XXYYZ
 510                  * dtest does like this assert.
 511                  */
 512                 /* assert( ber->ber_buf == NULL ); */
 513                 ber->ber_rwptr = (char *) &ber->ber_tag;
 514                 ber->ber_tag = 0;
 515         }
 516
 517 #define PTR_IN_VAR( ptr, var )\
 518 (((ptr)>=(char *) &(var)) && ((ptr)< (char *) &(var)+sizeof(var)))
 519
 520         if (PTR_IN_VAR(ber->ber_rwptr, ber->ber_tag)) {
 521                 if (ber->ber_rwptr == (char *) &ber->ber_tag) {
 522                         if (ber_pvt_sb_read( sb, ber->ber_rwptr, 1)<=0)
 523                                 return LBER_DEFAULT;
 524                         if ((ber->ber_rwptr[0] & LBER_BIG_TAG_MASK)
 525                                 != LBER_BIG_TAG_MASK) {
 526                                 ber->ber_tag = ber->ber_rwptr[0];
 527                                 ber->ber_rwptr = (char *) &ber->ber_usertag;
 528                                 goto get_lenbyte;
 529                         }
 530                         ber->ber_rwptr++;
 531                 }
 532                 do {
 533                         /* reading the tag... */
 534                         if (ber_pvt_sb_read( sb, ber->ber_rwptr, 1)<=0)
 535                                 return LBER_DEFAULT;
 536                         if (! (ber->ber_rwptr[0] & LBER_MORE_TAG_MASK) ) {
 537                                 ber->ber_tag>>=sizeof(ber->ber_tag) -
 538                                   ((char *) &ber->ber_tag - ber->ber_rwptr);
 539                                 ber->ber_rwptr = (char *) &ber->ber_usertag;
 540                                 goto get_lenbyte;
 541                         }
 542                 } while (PTR_IN_VAR(ber->ber_rwptr,ber->ber_tag));
 543                 errno = ERANGE; /* this is a serious error. */
 544                 return LBER_DEFAULT;
 545         }
 546 get_lenbyte:
 547         if (ber->ber_rwptr==(char *) &ber->ber_usertag) {
 548                 unsigned char c;
 549                 if (ber_pvt_sb_read( sb, (char *) &c, 1)<=0)
 550                         return LBER_DEFAULT;
 551                 if (c & 0x80U) {
 552                         int len = c & 0x7fU;
 553                         if ( (len==0) || ( len>sizeof( ber->ber_len ) ) ) {
 554                                 errno = ERANGE;
 555                                 return LBER_DEFAULT;
 556                         }
 557                         ber->ber_rwptr = (char *) &ber->ber_len +
 558                                 sizeof(ber->ber_len) - len;
 559                         ber->ber_len = 0;
 560                 } else {
 561                         ber->ber_len = c;
 562                         goto fill_buffer;
 563                 }
 564         }
 565         if (PTR_IN_VAR(ber->ber_rwptr, ber->ber_len)) {
 566                 ber_slen_t res;
 567                 ber_slen_t to_go;
 568                 to_go = (char *) &ber->ber_len + sizeof( ber->ber_len ) -
 569                         ber->ber_rwptr;
 570                 assert( to_go > 0 );
 571                 res = ber_pvt_sb_read( sb, ber->ber_rwptr, to_go );
 572                 if (res <=0)
 573                         return LBER_DEFAULT;
 574                 ber->ber_rwptr += res;
 575                 if (res==to_go) {
 576                         /* convert length. */
 577                         ber->ber_len = LBER_LEN_NTOH( ber->ber_len );
 578                         goto fill_buffer;
 579                 } else {
 580 #if defined( EWOULDBLOCK )
 581                         errno = EWOULDBLOCK;
 582 #elif defined( EAGAIN )
 583                         errno = EAGAIN;
 584 #endif
 585                         return LBER_DEFAULT;
 586                 }
 587         }
 588 fill_buffer:
 589         /* now fill the buffer. */
 590         if (ber->ber_buf==NULL) {
 591                 if (ber->ber_len > MAX_BERBUFSIZE) {
 592                         errno = ERANGE;
 593                         return LBER_DEFAULT;
 594                 }
 595                 ber->ber_buf = (char *) LBER_MALLOC( ber->ber_len );
 596                 if (ber->ber_buf==NULL)
 597                         return LBER_DEFAULT;
 598                 ber->ber_rwptr = ber->ber_buf;
 599                 ber->ber_ptr = ber->ber_buf;
 600                 ber->ber_end = ber->ber_buf + ber->ber_len;
 601         }
 602         if ((ber->ber_rwptr>=ber->ber_buf) && (ber->ber_rwptr<ber->ber_end)) {
 603                 ber_slen_t res;
 604                 ber_slen_t to_go;
 605
 606                 to_go = ber->ber_end - ber->ber_rwptr;
 607                 assert( to_go > 0 );
 608
 609                 res = ber_pvt_sb_read( sb, ber->ber_rwptr, to_go );
 610                 if (res<=0)
 611                         return LBER_DEFAULT;
 612                 ber->ber_rwptr+=res;
 613
 614                 if (res<to_go) {
 615 #if defined( EWOULDBLOCK )
 616                         errno = EWOULDBLOCK;
 617 #elif defined( EAGAIN )
 618                         errno = EAGAIN;
 619 #endif
 620                         return LBER_DEFAULT;
 621                 }
 622
 623                 ber->ber_rwptr = NULL;
 624                 *len = ber->ber_len;
 625                 if ( ber->ber_debug ) {
 626                         ber_log_printf( LDAP_DEBUG_TRACE, ber->ber_debug,
 627                                 "ber_get_next: tag 0x%lx len %ld contents:\n",
 628                                 ber->ber_tag, ber->ber_len );
 629                         ber_log_dump( LDAP_DEBUG_BER, ber->ber_debug, ber, 1 );
 630                 }
 631                 return (ber->ber_tag);
 632         }
 633         assert( 0 ); /* ber structure is messed up ?*/
 634         return LBER_DEFAULT;
 635 }