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