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

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