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