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 long BerRead LDAP_P(( Sockbuf *sb, char *buf, long len ));
  36 static int ber_realloc LDAP_P(( BerElement *ber, unsigned long len ));
  37
  38 #define EXBUFSIZ        1024
  39
  40 static long
  41 BerRead( Sockbuf *sb, char *buf, long len )
  42 {
  43         int     c;
  44         long    nread = 0;
  45
  46         while ( len > 0 ) {
  47                 if ( (c = lber_pvt_sb_read( sb, buf, len )) <= 0 ) {
  48                         if ( nread > 0 )
  49                                 break;
  50                         return( c );
  51                 }
  52                 buf+= c;
  53                 nread+=c;
  54                 len-=c;
  55         }
  56
  57         return( nread );
  58 }
  59
  60 long
  61 ber_read( BerElement *ber, char *buf, unsigned long len )
  62 {
  63         unsigned long   actuallen, nleft;
  64
  65         nleft = ber->ber_end - ber->ber_ptr;
  66         actuallen = nleft < len ? nleft : len;
  67
  68         SAFEMEMCPY( buf, ber->ber_ptr, (size_t)actuallen );
  69
  70         ber->ber_ptr += actuallen;
  71
  72         return( (long)actuallen );
  73 }
  74
  75 long
  76 ber_write( BerElement *ber, char *buf, unsigned long len, int nosos )
  77 {
  78         if ( nosos || ber->ber_sos == NULL ) {
  79                 if ( ber->ber_ptr + len > ber->ber_end ) {
  80                         if ( ber_realloc( ber, len ) != 0 )
  81                                 return( -1 );
  82                 }
  83                 SAFEMEMCPY( ber->ber_ptr, buf, (size_t)len );
  84                 ber->ber_ptr += len;
  85                 return( len );
  86         } else {
  87                 if ( ber->ber_sos->sos_ptr + len > ber->ber_end ) {
  88                         if ( ber_realloc( ber, len ) != 0 )
  89                                 return( -1 );
  90                 }
  91                 SAFEMEMCPY( ber->ber_sos->sos_ptr, buf, (size_t)len );
  92                 ber->ber_sos->sos_ptr += len;
  93                 ber->ber_sos->sos_clen += len;
  94                 return( len );
  95         }
  96 }
  97
  98 static int
  99 ber_realloc( BerElement *ber, unsigned long len )
 100 {
 101         unsigned long   need, have, total;
 102         Seqorset        *s;
 103         long            off;
 104         char            *oldbuf;
 105
 106         have = (ber->ber_end - ber->ber_buf) / EXBUFSIZ;
 107         need = (len < EXBUFSIZ ? 1 : (len + (EXBUFSIZ - 1)) / EXBUFSIZ);
 108         total = have * EXBUFSIZ + need * EXBUFSIZ;
 109
 110         oldbuf = ber->ber_buf;
 111
 112         if ( ber->ber_buf == NULL ) {
 113                 if ( (ber->ber_buf = (char *) malloc( (size_t)total )) == NULL )
 114                         return( -1 );
 115         } else if ( (ber->ber_buf = (char *) realloc( ber->ber_buf,
 116             (size_t)total )) == NULL )
 117                 return( -1 );
 118
 119         ber->ber_end = ber->ber_buf + total;
 120
 121         /*
 122          * If the stinking thing was moved, we need to go through and
 123          * reset all the sos and ber pointers.  Offsets would've been
 124          * a better idea... oh well.
 125          */
 126
 127         if ( ber->ber_buf != oldbuf ) {
 128                 ber->ber_ptr = ber->ber_buf + (ber->ber_ptr - oldbuf);
 129
 130                 for ( s = ber->ber_sos; s != NULLSEQORSET; s = s->sos_next ) {
 131                         off = s->sos_first - oldbuf;
 132                         s->sos_first = ber->ber_buf + off;
 133
 134                         off = s->sos_ptr - oldbuf;
 135                         s->sos_ptr = ber->ber_buf + off;
 136                 }
 137         }
 138
 139         return( 0 );
 140 }
 141
 142 void
 143 ber_free( BerElement *ber, int freebuf )
 144 {
 145         if ( freebuf && ber->ber_buf != NULL )
 146                 free( ber->ber_buf );
 147         ber->ber_buf = NULL;
 148         free( (char *) ber );
 149 }
 150
 151 int
 152 ber_flush( Sockbuf *sb, BerElement *ber, int freeit )
 153 {
 154         long    nwritten, towrite, rc;
 155
 156         if ( ber->ber_rwptr == NULL ) {
 157                 ber->ber_rwptr = ber->ber_buf;
 158         }
 159         towrite = ber->ber_ptr - ber->ber_rwptr;
 160
 161         if ( sb->sb_debug ) {
 162                 lber_log_printf( LDAP_DEBUG_ANY, sb->sb_debug,
 163                         "ber_flush: %ld bytes to sd %ld%s\n", towrite,
 164                     (long) sb->sb_sd, ber->ber_rwptr != ber->ber_buf ? " (re-flush)"
 165                     : "" );
 166                 lber_log_bprint( LDAP_DEBUG_PACKETS, sb->sb_debug,
 167                         ber->ber_rwptr, towrite );
 168         }
 169
 170 #if !defined(MACOS) && !defined(DOS)
 171         if ( sb->sb_options & (LBER_TO_FILE | LBER_TO_FILE_ONLY) ) {
 172                 rc = write( sb->sb_fd, ber->ber_rwptr, towrite );
 173                 if ( sb->sb_options & LBER_TO_FILE_ONLY ) {
 174                         return( (int)rc );
 175                 }
 176         }
 177 #endif
 178
 179         nwritten = 0;
 180         do {
 181                 rc = lber_pvt_sb_write( sb, ber->ber_rwptr, towrite );
 182                 if (rc<=0) {
 183                         return -1;
 184                 }
 185                 towrite -= rc;
 186                 nwritten += rc;
 187                 ber->ber_rwptr += rc;
 188         } while ( towrite > 0 );
 189
 190         if ( freeit )
 191                 ber_free( ber, 1 );
 192
 193         return( 0 );
 194 }
 195
 196 BerElement *
 197 ber_alloc_t( int options )
 198 {
 199         BerElement      *ber;
 200
 201         if ( (ber = (BerElement *) calloc( 1, sizeof(BerElement) )) == NULLBER )
 202                 return( NULLBER );
 203         ber->ber_tag = LBER_DEFAULT;
 204         ber->ber_options = options;
 205         ber->ber_debug = lber_int_debug;
 206
 207         return( ber );
 208 }
 209
 210 BerElement *
 211 ber_alloc( void )
 212 {
 213         return( ber_alloc_t( 0 ) );
 214 }
 215
 216 BerElement *
 217 der_alloc( void )
 218 {
 219         return( ber_alloc_t( LBER_USE_DER ) );
 220 }
 221
 222 BerElement *
 223 ber_dup( BerElement *ber )
 224 {
 225         BerElement      *new;
 226
 227         if ( (new = ber_alloc()) == NULLBER )
 228                 return( NULLBER );
 229
 230         *new = *ber;
 231
 232         return( new );
 233 }
 234
 235
 236 /* OLD U-Mich ber_init() */
 237 void
 238 ber_init_w_nullc( BerElement *ber, int options )
 239 {
 240         (void) memset( (char *)ber, '\0', sizeof( BerElement ));
 241         ber->ber_tag = LBER_DEFAULT;
 242         ber->ber_options = (char) options;
 243 }
 244
 245 /* New C-API ber_init() */
 246 /* This function constructs a BerElement containing a copy
 247 ** of the data in the bv argument.
 248 */
 249 BerElement *
 250 ber_init( struct berval *bv )
 251 {
 252         BerElement *ber;
 253
 254         if ( bv == NULL ) {
 255                 return NULL;
 256         }
 257
 258         ber = ber_alloc_t( 0 );
 259
 260         if( ber == NULLBER ) {
 261                 /* allocation failed */
 262                 return ( NULL );
 263         }
 264
 265         /* copy the data */
 266         if ( ( (unsigned int) ber_write ( ber, bv->bv_val, bv->bv_len, 0 )) != bv->bv_len ) {
 267                 /* write failed, so free and return NULL */
 268                 ber_free( ber, 1 );
 269                 return( NULL );
 270         }
 271
 272         ber_reset( ber, 1 );    /* reset the pointer to the start of the buffer */
 273
 274         return ( ber );
 275 }
 276
 277 /* New C-API ber_flatten routine */
 278 /* This routine allocates a struct berval whose contents are a BER
 279 ** encoding taken from the ber argument.  The bvPtr pointer pointers to
 280 ** the returned berval.
 281 */
 282 int ber_flatten(
 283         BerElement *ber,
 284         struct berval **bvPtr)
 285 {
 286         struct berval *bv;
 287
 288         if(bvPtr == NULL) {
 289                 return( -1 );
 290         }
 291
 292         if ( (bv = malloc( sizeof(struct berval))) == NULL ) {
 293                 return( -1 );
 294         }
 295
 296         if ( ber == NULL ) {
 297                 /* ber is null, create an empty berval */
 298                 bv->bv_val = NULL;
 299                 bv->bv_len = 0;
 300
 301         } else {
 302                 /* copy the berval */
 303                 ptrdiff_t len = ber->ber_ptr - ber->ber_buf;
 304
 305                 if ( (bv->bv_val = (char *) malloc( len + 1 )) == NULL ) {
 306                         ber_bvfree( bv );
 307                         return( -1 );
 308                 }
 309
 310                 SAFEMEMCPY( bv->bv_val, ber->ber_buf, (size_t)len );
 311                 bv->bv_val[len] = '\0';
 312                 bv->bv_len = len;
 313         }
 314
 315         *bvPtr = bv;
 316         return( 0 );
 317 }
 318
 319 void
 320 ber_reset( BerElement *ber, int was_writing )
 321 {
 322         if ( was_writing ) {
 323                 ber->ber_end = ber->ber_ptr;
 324                 ber->ber_ptr = ber->ber_buf;
 325         } else {
 326                 ber->ber_ptr = ber->ber_end;
 327         }
 328
 329         ber->ber_rwptr = NULL;
 330 }
 331
 332 /* return the tag - LBER_DEFAULT returned means trouble */
 333 static unsigned long
 334 get_tag( Sockbuf *sb )
 335 {
 336         unsigned char   xbyte;
 337         unsigned long   tag;
 338         char            *tagp;
 339         unsigned int    i;
 340
 341         if ( lber_pvt_sb_read( sb, (char *) &xbyte, 1 ) != 1 )
 342                 return( LBER_DEFAULT );
 343
 344         if ( (xbyte & LBER_BIG_TAG_MASK) != LBER_BIG_TAG_MASK )
 345                 return( (unsigned long) xbyte );
 346
 347         tagp = (char *) &tag;
 348         tagp[0] = xbyte;
 349         for ( i = 1; i < sizeof(long); i++ ) {
 350                 if ( lber_pvt_sb_read( sb, (char *) &xbyte, 1 ) != 1 )
 351                         return( LBER_DEFAULT );
 352
 353                 tagp[i] = xbyte;
 354
 355                 if ( ! (xbyte & LBER_MORE_TAG_MASK) )
 356                         break;
 357         }
 358
 359         /* tag too big! */
 360         if ( i == sizeof(long) )
 361                 return( LBER_DEFAULT );
 362
 363         /* want leading, not trailing 0's */
 364         return( tag >> (sizeof(long) - i - 1) );
 365 }
 366
 367 unsigned long
 368 ber_get_next( Sockbuf *sb, unsigned long *len, BerElement *ber )
 369 {
 370         unsigned long   tag = 0, netlen, toread;
 371         unsigned char   lc;
 372         long            rc;
 373         long            noctets;
 374         unsigned int    diff;
 375
 376         if ( ber->ber_debug ) {
 377                 lber_log_printf( LDAP_DEBUG_TRACE, ber->ber_debug,
 378                         "ber_get_next\n" );
 379         }
 380
 381         /*
 382          * Any ber element looks like this: tag length contents.
 383          * Assuming everything's ok, we return the tag byte (we
 384          * can assume a single byte), return the length in len,
 385          * and the rest of the undecoded element in buf.
 386          *
 387          * Assumptions:
 388          *      1) small tags (less than 128)
 389          *      2) definite lengths
 390          *      3) primitive encodings used whenever possible
 391          */
 392
 393         /*
 394          * first time through - malloc the buffer, set up ptrs, and
 395          * read the tag and the length and as much of the rest as we can
 396          */
 397
 398         if ( ber->ber_rwptr == NULL ) {
 399                 /*
 400                  * First, we read the tag.
 401                  */
 402
 403                 if ( (tag = get_tag( sb )) == LBER_DEFAULT ) {
 404                         return( LBER_DEFAULT );
 405                 }
 406                 ber->ber_tag = tag;
 407
 408                 /*
 409                  * Next, read the length.  The first byte contains the length
 410                  * of the length.  If bit 8 is set, the length is the long
 411                  * form, otherwise it's the short form.  We don't allow a
 412                  * length that's greater than what we can hold in an unsigned
 413                  * long.
 414                  */
 415
 416                 *len = netlen = 0;
 417                 if ( lber_pvt_sb_read( sb, (char *) &lc, 1 ) != 1 ) {
 418                         return( LBER_DEFAULT );
 419                 }
 420                 if ( lc & 0x80 ) {
 421                         noctets = (lc & 0x7f);
 422                         if ( noctets > sizeof(unsigned long) )
 423                                 return( LBER_DEFAULT );
 424                         diff = sizeof(unsigned long) - noctets;
 425                         if ( BerRead( sb, (char *) &netlen + diff, noctets ) !=
 426                             noctets ) {
 427                                 return( LBER_DEFAULT );
 428                         }
 429                         *len = AC_NTOHL( netlen );
 430                 } else {
 431                         *len = lc;
 432                 }
 433                 ber->ber_len = *len;
 434
 435                 /*
 436                  * Finally, malloc a buffer for the contents and read it in.
 437                  * It's this buffer that's passed to all the other ber decoding
 438                  * routines.
 439                  */
 440
 441 #if defined( DOS ) && !defined( _WIN32 )
 442                 if ( *len > 65535 ) {   /* DOS can't allocate > 64K */
 443                     return( LBER_DEFAULT );
 444                 }
 445 #endif /* DOS && !_WIN32 */
 446 #ifdef DEADWOOD
 447                 if ( ( sb->sb_options & LBER_MAX_INCOMING_SIZE ) &&
 448                     *len > (unsigned long) sb->sb_max_incoming ) {
 449                         return( LBER_DEFAULT );
 450                 }
 451 #endif
 452                 if ( (ber->ber_buf = (char *) malloc( (size_t)*len )) == NULL ) {
 453                         return( LBER_DEFAULT );
 454                 }
 455                 ber->ber_ptr = ber->ber_buf;
 456                 ber->ber_end = ber->ber_buf + *len;
 457                 ber->ber_rwptr = ber->ber_buf;
 458         }
 459
 460         toread = (unsigned long)ber->ber_end - (unsigned long)ber->ber_rwptr;
 461         do {
 462                 if ( (rc = lber_pvt_sb_read( sb, ber->ber_rwptr, (long)toread )) <= 0 ) {
 463                         return( LBER_DEFAULT );
 464                 }
 465
 466                 toread -= rc;
 467                 ber->ber_rwptr += rc;
 468         } while ( toread > 0 );
 469
 470         if ( ber->ber_debug ) {
 471                 lber_log_printf( LDAP_DEBUG_TRACE, ber->ber_debug,
 472                         "ber_get_next: tag 0x%lx len %ld contents:\n",
 473                     tag, ber->ber_len );
 474
 475                 lber_log_dump( LDAP_DEBUG_BER, ber->ber_debug, ber, 1 );
 476         }
 477
 478         *len = ber->ber_len;
 479         ber->ber_rwptr = NULL;
 480         return( ber->ber_tag );
 481 }
 482
 483 Sockbuf *lber_pvt_sb_alloc( void )
 484 {
 485         Sockbuf *sb = calloc(1, sizeof(Sockbuf));
 486         lber_pvt_sb_init( sb );
 487         return sb;
 488 }
 489
 490 Sockbuf *lber_pvt_sb_alloc_fd( int fd )
 491 {
 492         Sockbuf *sb = lber_pvt_sb_alloc();
 493         lber_pvt_sb_set_desc( sb, fd );
 494         lber_pvt_sb_set_io( sb, &lber_pvt_sb_io_tcp, NULL );
 495         return sb;
 496 }
 497
 498 void lber_pvt_sb_free( Sockbuf *sb )
 499 {
 500         if(sb == NULL) return;
 501         lber_pvt_sb_destroy( sb );
 502         free(sb);
 503 }
 504
 505 int lber_pvt_sb_get_option( Sockbuf *sb, int opt, void *outvalue )
 506 {
 507         return LBER_OPT_ERROR;
 508 }
 509
 510 int lber_pvt_sb_set_option( Sockbuf *sb, int opt, void *invalue )
 511 {
 512         return LBER_OPT_ERROR;
 513 }