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

   1 /* io.c - ber general i/o routines */
   2 /*
   3  * Copyright (c) 1990 Regents of the University of Michigan.
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms are permitted
   7  * provided that this notice is preserved and that due credit is given
   8  * to the University of Michigan at Ann Arbor. The name of the University
   9  * may not be used to endorse or promote products derived from this
  10  * software without specific prior written permission. This software
  11  * is provided ``as is'' without express or implied warranty.
  12  */
  13
  14 #include "portable.h"
  15
  16 #include <stdio.h>
  17 #include <stdlib.h>
  18
  19 #include <ac/ctype.h>
  20 #include <ac/errno.h>
  21 #include <ac/socket.h>
  22 #include <ac/string.h>
  23 #include <ac/unistd.h>
  24
  25 #ifdef HAVE_IO_H
  26 #include <io.h>
  27 #endif
  28
  29 #include "lber-int.h"
  30
  31 static int ber_realloc LDAP_P(( BerElement *ber, unsigned long len ));
  32 static int ber_filbuf LDAP_P(( Sockbuf *sb, long len ));
  33 static long BerRead LDAP_P(( Sockbuf *sb, char *buf, long len ));
  34 #ifdef PCNFS
  35 static int BerWrite LDAP_P(( Sockbuf *sb, char *buf, long len ));
  36 #endif /* PCNFS */
  37
  38 #define bergetc( sb, len )    ( sb->sb_ber.ber_end > sb->sb_ber.ber_ptr ? \
  39                           (unsigned char)*sb->sb_ber.ber_ptr++ : \
  40                           ber_filbuf( sb, len ))
  41
  42 #ifdef MACOS
  43 /*
  44  * MacTCP/OpenTransport
  45  */
  46 #define read( s, b, l ) tcpread( s, 0, (unsigned char *)b, l, NULL )
  47 #define MAX_WRITE       65535
  48 #define BerWrite( sb, b, l )   tcpwrite( sb->sb_sd, (unsigned char *)(b), (l<MAX_WRITE)? l : MAX_WRITE )
  49 #else /* MACOS */
  50 #ifdef DOS
  51 #ifdef PCNFS
  52 /*
  53  * PCNFS (under DOS)
  54  */
  55 #define read( s, b, l ) recv( s, b, l, 0 )
  56 #define BerWrite( s, b, l ) send( s->sb_sd, b, (int) l, 0 )
  57 #endif /* PCNFS */
  58 #ifdef NCSA
  59 /*
  60  * NCSA Telnet TCP/IP stack (under DOS)
  61  */
  62 #define read( s, b, l ) nread( s, b, l )
  63 #define BerWrite( s, b, l ) netwrite( s->sb_sd, b, l )
  64 #endif /* NCSA */
  65 #ifdef WINSOCK
  66 /*
  67  * Windows Socket API (under DOS/Windows 3.x)
  68  */
  69 #define read( s, b, l ) recv( s, b, l, 0 )
  70 #define BerWrite( s, b, l ) send( s->sb_sd, b, l, 0 )
  71 #endif /* WINSOCK */
  72 #else /* DOS */
  73 #ifdef _WIN32
  74 /*
  75  * 32-bit Windows Socket API (under Windows NT or Windows 95)
  76  */
  77 #define read( s, b, l )         recv( s, b, l, 0 )
  78 #define BerWrite( s, b, l )     send( s->sb_sd, b, l, 0 )
  79 #else /* _WIN32 */
  80 #ifdef VMS
  81 /*
  82  * VMS -- each write must be 64K or smaller
  83  */
  84 #define MAX_WRITE 65535
  85 #define BerWrite( sb, b, l ) write( sb->sb_sd, b, (l<MAX_WRITE)? l : MAX_WRITE)
  86 #else /* VMS */
  87 /*
  88  * everything else (Unix/BSD 4.3 socket API)
  89  */
  90 #define BerWrite( sb, b, l )    write( sb->sb_sd, b, l )
  91 #endif /* VMS */
  92 #define udp_read( sb, b, l, al ) recvfrom(sb->sb_sd, (char *)b, l, 0, \
  93                 (struct sockaddr *)sb->sb_fromaddr, \
  94                 (al = sizeof(struct sockaddr), &al))
  95 #define udp_write( sb, b, l ) sendto(sb->sb_sd, (char *)(b), l, 0, \
  96                 (struct sockaddr *)sb->sb_useaddr, sizeof(struct sockaddr))
  97 #endif /* _WIN32 */
  98 #endif /* DOS */
  99 #endif /* MACOS */
 100
 101 #ifndef udp_read
 102 #define udp_read( sb, b, l, al )        CLDAP NOT SUPPORTED
 103 #define udp_write( sb, b, l )           CLDAP NOT SUPPORTED
 104 #endif /* udp_read */
 105
 106 #define EXBUFSIZ        1024
 107
 108 static int
 109 ber_filbuf( Sockbuf *sb, long len )
 110 {
 111         short   rc;
 112 #ifdef LDAP_CONNECTIONLESS
 113         int     addrlen;
 114 #endif /* LDAP_CONNECTIONLESS */
 115
 116         if ( sb->sb_ber.ber_buf == NULL ) {
 117                 if ( (sb->sb_ber.ber_buf = (char *) malloc( READBUFSIZ )) ==
 118                     NULL )
 119                         return( -1 );
 120                 sb->sb_ber.ber_ptr = sb->sb_ber.ber_buf;
 121                 sb->sb_ber.ber_end = sb->sb_ber.ber_buf;
 122         }
 123
 124         if ( sb->sb_naddr > 0 ) {
 125 #ifdef LDAP_CONNECTIONLESS
 126                 rc = udp_read(sb, sb->sb_ber.ber_buf, READBUFSIZ, addrlen );
 127
 128                 if ( sb->sb_debug ) {
 129                         lber_log_printf( LDAP_DEBUG_ANY, sb->sb_debug,
 130                                 "ber_filbuf udp_read %d bytes\n",
 131                                         rc );
 132                         if ( rc > 0 )
 133                                 lber_log_bprint( LDAP_DEBUG_PACKETS, sb->sb_debug,
 134                                         sb->sb_ber.ber_buf, rc );
 135                 }
 136 #else /* LDAP_CONNECTIONLESS */
 137                 rc = -1;
 138 #endif /* LDAP_CONNECTIONLESS */
 139         } else {
 140                 rc = read( sb->sb_sd, sb->sb_ber.ber_buf,
 141                         ((sb->sb_options & LBER_NO_READ_AHEAD) && (len < READBUFSIZ)) ?
 142                                 len : READBUFSIZ );
 143         }
 144
 145         if ( rc > 0 ) {
 146                 sb->sb_ber.ber_ptr = sb->sb_ber.ber_buf + 1;
 147                 sb->sb_ber.ber_end = sb->sb_ber.ber_buf + rc;
 148                 return( (unsigned char)*sb->sb_ber.ber_buf );
 149         }
 150
 151         return( -1 );
 152 }
 153
 154
 155 static long
 156 BerRead( Sockbuf *sb, char *buf, long len )
 157 {
 158         int     c;
 159         long    nread = 0;
 160
 161         while ( len > 0 ) {
 162                 if ( (c = bergetc( sb, len )) < 0 ) {
 163                         if ( nread > 0 )
 164                                 break;
 165                         return( c );
 166                 }
 167                 *buf++ = (char) c;
 168                 nread++;
 169                 len--;
 170         }
 171
 172         return( nread );
 173 }
 174
 175
 176 long
 177 ber_read( BerElement *ber, char *buf, unsigned long len )
 178 {
 179         unsigned long   actuallen, nleft;
 180
 181         nleft = ber->ber_end - ber->ber_ptr;
 182         actuallen = nleft < len ? nleft : len;
 183
 184         SAFEMEMCPY( buf, ber->ber_ptr, (size_t)actuallen );
 185
 186         ber->ber_ptr += actuallen;
 187
 188         return( (long)actuallen );
 189 }
 190
 191 long
 192 ber_write( BerElement *ber, char *buf, unsigned long len, int nosos )
 193 {
 194         if ( nosos || ber->ber_sos == NULL ) {
 195                 if ( ber->ber_ptr + len > ber->ber_end ) {
 196                         if ( ber_realloc( ber, len ) != 0 )
 197                                 return( -1 );
 198                 }
 199                 SAFEMEMCPY( ber->ber_ptr, buf, (size_t)len );
 200                 ber->ber_ptr += len;
 201                 return( len );
 202         } else {
 203                 if ( ber->ber_sos->sos_ptr + len > ber->ber_end ) {
 204                         if ( ber_realloc( ber, len ) != 0 )
 205                                 return( -1 );
 206                 }
 207                 SAFEMEMCPY( ber->ber_sos->sos_ptr, buf, (size_t)len );
 208                 ber->ber_sos->sos_ptr += len;
 209                 ber->ber_sos->sos_clen += len;
 210                 return( len );
 211         }
 212 }
 213
 214 static int
 215 ber_realloc( BerElement *ber, unsigned long len )
 216 {
 217         unsigned long   need, have, total;
 218         Seqorset        *s;
 219         long            off;
 220         char            *oldbuf;
 221
 222         have = (ber->ber_end - ber->ber_buf) / EXBUFSIZ;
 223         need = (len < EXBUFSIZ ? 1 : (len + (EXBUFSIZ - 1)) / EXBUFSIZ);
 224         total = have * EXBUFSIZ + need * EXBUFSIZ;
 225
 226         oldbuf = ber->ber_buf;
 227
 228         if ( ber->ber_buf == NULL ) {
 229                 if ( (ber->ber_buf = (char *) malloc( (size_t)total )) == NULL )
 230                         return( -1 );
 231         } else if ( (ber->ber_buf = (char *) realloc( ber->ber_buf,
 232             (size_t)total )) == NULL )
 233                 return( -1 );
 234
 235         ber->ber_end = ber->ber_buf + total;
 236
 237         /*
 238          * If the stinking thing was moved, we need to go through and
 239          * reset all the sos and ber pointers.  Offsets would've been
 240          * a better idea... oh well.
 241          */
 242
 243         if ( ber->ber_buf != oldbuf ) {
 244                 ber->ber_ptr = ber->ber_buf + (ber->ber_ptr - oldbuf);
 245
 246                 for ( s = ber->ber_sos; s != NULLSEQORSET; s = s->sos_next ) {
 247                         off = s->sos_first - oldbuf;
 248                         s->sos_first = ber->ber_buf + off;
 249
 250                         off = s->sos_ptr - oldbuf;
 251                         s->sos_ptr = ber->ber_buf + off;
 252                 }
 253         }
 254
 255         return( 0 );
 256 }
 257
 258 void
 259 ber_free( BerElement *ber, int freebuf )
 260 {
 261         if ( freebuf && ber->ber_buf != NULL )
 262                 free( ber->ber_buf );
 263         free( (char *) ber );
 264 }
 265
 266 int
 267 ber_flush( Sockbuf *sb, BerElement *ber, int freeit )
 268 {
 269         long    nwritten, towrite, rc;
 270
 271         if ( ber->ber_rwptr == NULL ) {
 272                 ber->ber_rwptr = ber->ber_buf;
 273         }
 274         towrite = ber->ber_ptr - ber->ber_rwptr;
 275
 276         if ( sb->sb_debug ) {
 277                 lber_log_printf( LDAP_DEBUG_ANY, sb->sb_debug,
 278                         "ber_flush: %ld bytes to sd %ld%s\n", towrite,
 279                     (long) sb->sb_sd, ber->ber_rwptr != ber->ber_buf ? " (re-flush)"
 280                     : "" );
 281                 lber_log_bprint( LDAP_DEBUG_PACKETS, sb->sb_debug,
 282                         ber->ber_rwptr, towrite );
 283         }
 284
 285 #if !defined(MACOS) && !defined(DOS)
 286         if ( sb->sb_options & (LBER_TO_FILE | LBER_TO_FILE_ONLY) ) {
 287                 rc = write( sb->sb_fd, ber->ber_buf, towrite );
 288                 if ( sb->sb_options & LBER_TO_FILE_ONLY ) {
 289                         return( (int)rc );
 290                 }
 291         }
 292 #endif
 293
 294         nwritten = 0;
 295         do {
 296                 if (sb->sb_naddr > 0) {
 297 #ifdef LDAP_CONNECTIONLESS
 298                         rc = udp_write( sb, ber->ber_buf + nwritten,
 299                             (size_t)towrite );
 300 #else /* LDAP_CONNECTIONLESS */
 301                         rc = -1;
 302 #endif /* LDAP_CONNECTIONLESS */
 303                         if ( rc <= 0 )
 304                                 return( -1 );
 305
 306                         /* fake error if write was not atomic */
 307                         if (rc < towrite) {
 308 #ifdef EMSGSIZE
 309                             errno = EMSGSIZE;
 310 #endif
 311                             return( -1 );
 312                         }
 313                 } else {
 314                         if ( (rc = BerWrite( sb, ber->ber_rwptr,
 315                             (size_t) towrite )) <= 0 ) {
 316                                 return( -1 );
 317                         }
 318                 }
 319                 towrite -= rc;
 320                 nwritten += rc;
 321                 ber->ber_rwptr += rc;
 322         } while ( towrite > 0 );
 323
 324         if ( freeit )
 325                 ber_free( ber, 1 );
 326
 327         return( 0 );
 328 }
 329
 330 BerElement *
 331 ber_alloc_t( int options )
 332 {
 333         BerElement      *ber;
 334
 335         if ( (ber = (BerElement *) calloc( 1, sizeof(BerElement) )) == NULLBER )
 336                 return( NULLBER );
 337         ber->ber_tag = LBER_DEFAULT;
 338         ber->ber_options = options;
 339         ber->ber_debug = lber_int_debug;
 340
 341         return( ber );
 342 }
 343
 344 BerElement *
 345 ber_alloc( void )
 346 {
 347         return( ber_alloc_t( 0 ) );
 348 }
 349
 350 BerElement *
 351 der_alloc( void )
 352 {
 353         return( ber_alloc_t( LBER_USE_DER ) );
 354 }
 355
 356 BerElement *
 357 ber_dup( BerElement *ber )
 358 {
 359         BerElement      *new;
 360
 361         if ( (new = ber_alloc()) == NULLBER )
 362                 return( NULLBER );
 363
 364         *new = *ber;
 365
 366         return( new );
 367 }
 368
 369
 370 /* OLD U-Mich ber_init() */
 371 void
 372 ber_init_w_nullc( BerElement *ber, int options )
 373 {
 374         (void) memset( (char *)ber, '\0', sizeof( BerElement ));
 375         ber->ber_tag = LBER_DEFAULT;
 376         ber->ber_options = (char) options;
 377 }
 378
 379 /* New C-API ber_init() */
 380 /* This function constructs a BerElement containing a copy
 381 ** of the data in the bv argument.
 382 */
 383 BerElement *
 384 ber_init( struct berval *bv )
 385 {
 386         BerElement *ber;
 387
 388         if ( bv == NULL ) {
 389                 return NULL;
 390         }
 391
 392         ber = ber_alloc_t( 0 );
 393
 394         if( ber == NULLBER ) {
 395                 /* allocation failed */
 396                 return ( NULL );
 397         }
 398
 399         /* copy the data */
 400         if ( (ber_write ( ber, bv->bv_val, bv->bv_len, 0 )) != bv->bv_len ) {
 401                 /* write failed, so free and return NULL */
 402                 ber_free( ber, 1 );
 403                 return( NULL );
 404         }
 405
 406         ber_reset( ber, 1 );    /* reset the pointer to the start of the buffer */
 407
 408         return ( ber );
 409 }
 410
 411 /* New C-API ber_flatten routine */
 412 /* This routine allocates a struct berval whose contents are a BER
 413 ** encoding taken from the ber argument.  The bvPtr pointer pointers to
 414 ** the returned berval.
 415 */
 416 int ber_flatten(
 417         BerElement *ber,
 418         struct berval **bvPtr)
 419 {
 420         struct berval *bv;
 421
 422         if(bvPtr == NULL) {
 423                 return( -1 );
 424         }
 425
 426         if ( (bv = malloc( sizeof(struct berval))) == NULL ) {
 427                 return( -1 );
 428         }
 429
 430         if ( ber == NULL ) {
 431                 /* ber is null, create an empty berval */
 432                 bv->bv_val = NULL;
 433                 bv->bv_len = 0;
 434
 435         } else {
 436                 /* copy the berval */
 437                 ptrdiff_t len = ber->ber_ptr - ber->ber_buf;
 438
 439                 if ( (bv->bv_val = (char *) malloc( len + 1 )) == NULL ) {
 440                         ber_bvfree( bv );
 441                         return( -1 );
 442                 }
 443
 444                 SAFEMEMCPY( bv->bv_val, ber->ber_buf, (size_t)len );
 445                 bv->bv_val[len] = '\0';
 446                 bv->bv_len = len;
 447         }
 448
 449         *bvPtr = bv;
 450         return( 0 );
 451 }
 452
 453 void
 454 ber_reset( BerElement *ber, int was_writing )
 455 {
 456         if ( was_writing ) {
 457                 ber->ber_end = ber->ber_ptr;
 458                 ber->ber_ptr = ber->ber_buf;
 459         } else {
 460                 ber->ber_ptr = ber->ber_end;
 461         }
 462
 463         ber->ber_rwptr = NULL;
 464 }
 465
 466 /* return the tag - LBER_DEFAULT returned means trouble */
 467 static unsigned long
 468 get_tag( Sockbuf *sb )
 469 {
 470         unsigned char   xbyte;
 471         unsigned long   tag;
 472         char            *tagp;
 473         unsigned int    i;
 474
 475         if ( BerRead( sb, (char *) &xbyte, 1 ) != 1 )
 476                 return( LBER_DEFAULT );
 477
 478         if ( (xbyte & LBER_BIG_TAG_MASK) != LBER_BIG_TAG_MASK )
 479                 return( (unsigned long) xbyte );
 480
 481         tagp = (char *) &tag;
 482         tagp[0] = xbyte;
 483         for ( i = 1; i < sizeof(long); i++ ) {
 484                 if ( BerRead( sb, (char *) &xbyte, 1 ) != 1 )
 485                         return( LBER_DEFAULT );
 486
 487                 tagp[i] = xbyte;
 488
 489                 if ( ! (xbyte & LBER_MORE_TAG_MASK) )
 490                         break;
 491         }
 492
 493         /* tag too big! */
 494         if ( i == sizeof(long) )
 495                 return( LBER_DEFAULT );
 496
 497         /* want leading, not trailing 0's */
 498         return( tag >> (sizeof(long) - i - 1) );
 499 }
 500
 501 unsigned long
 502 ber_get_next( Sockbuf *sb, unsigned long *len, BerElement *ber )
 503 {
 504         unsigned long   tag = 0, netlen, toread;
 505         unsigned char   lc;
 506         long            rc;
 507         long            noctets;
 508         unsigned int    diff;
 509
 510         if ( ber->ber_debug ) {
 511                 lber_log_printf( LDAP_DEBUG_TRACE, ber->ber_debug,
 512                         "ber_get_next\n" );
 513         }
 514
 515         /*
 516          * Any ber element looks like this: tag length contents.
 517          * Assuming everything's ok, we return the tag byte (we
 518          * can assume a single byte), return the length in len,
 519          * and the rest of the undecoded element in buf.
 520          *
 521          * Assumptions:
 522          *      1) small tags (less than 128)
 523          *      2) definite lengths
 524          *      3) primitive encodings used whenever possible
 525          */
 526
 527         /*
 528          * first time through - malloc the buffer, set up ptrs, and
 529          * read the tag and the length and as much of the rest as we can
 530          */
 531
 532         if ( ber->ber_rwptr == NULL ) {
 533                 /*
 534                  * First, we read the tag.
 535                  */
 536
 537                 if ( (tag = get_tag( sb )) == LBER_DEFAULT ) {
 538                         return( LBER_DEFAULT );
 539                 }
 540                 ber->ber_tag = tag;
 541
 542                 /*
 543                  * Next, read the length.  The first byte contains the length
 544                  * of the length.  If bit 8 is set, the length is the long
 545                  * form, otherwise it's the short form.  We don't allow a
 546                  * length that's greater than what we can hold in an unsigned
 547                  * long.
 548                  */
 549
 550                 *len = netlen = 0;
 551                 if ( BerRead( sb, (char *) &lc, 1 ) != 1 ) {
 552                         return( LBER_DEFAULT );
 553                 }
 554                 if ( lc & 0x80 ) {
 555                         noctets = (lc & 0x7f);
 556                         if ( noctets > sizeof(unsigned long) )
 557                                 return( LBER_DEFAULT );
 558                         diff = sizeof(unsigned long) - noctets;
 559                         if ( BerRead( sb, (char *) &netlen + diff, noctets ) !=
 560                             noctets ) {
 561                                 return( LBER_DEFAULT );
 562                         }
 563                         *len = AC_NTOHL( netlen );
 564                 } else {
 565                         *len = lc;
 566                 }
 567                 ber->ber_len = *len;
 568
 569                 /*
 570                  * Finally, malloc a buffer for the contents and read it in.
 571                  * It's this buffer that's passed to all the other ber decoding
 572                  * routines.
 573                  */
 574
 575 #if defined( DOS ) && !defined( _WIN32 )
 576                 if ( *len > 65535 ) {   /* DOS can't allocate > 64K */
 577                     return( LBER_DEFAULT );
 578                 }
 579 #endif /* DOS && !_WIN32 */
 580
 581                 if ( ( sb->sb_options & LBER_MAX_INCOMING_SIZE ) &&
 582                     *len > (unsigned long) sb->sb_max_incoming ) {
 583                         return( LBER_DEFAULT );
 584                 }
 585
 586                 if ( (ber->ber_buf = (char *) malloc( (size_t)*len )) == NULL ) {
 587                         return( LBER_DEFAULT );
 588                 }
 589                 ber->ber_ptr = ber->ber_buf;
 590                 ber->ber_end = ber->ber_buf + *len;
 591                 ber->ber_rwptr = ber->ber_buf;
 592         }
 593
 594         toread = (unsigned long)ber->ber_end - (unsigned long)ber->ber_rwptr;
 595         do {
 596                 if ( (rc = BerRead( sb, ber->ber_rwptr, (long)toread )) <= 0 ) {
 597                         return( LBER_DEFAULT );
 598                 }
 599
 600                 toread -= rc;
 601                 ber->ber_rwptr += rc;
 602         } while ( toread > 0 );
 603
 604         if ( ber->ber_debug ) {
 605                 lber_log_printf( LDAP_DEBUG_TRACE, ber->ber_debug,
 606                         "ber_get_next: tag 0x%lx len %ld contents:\n",
 607                     tag, ber->ber_len );
 608
 609                 lber_log_dump( LDAP_DEBUG_BER, ber->ber_debug, ber, 1 );
 610         }
 611
 612         *len = ber->ber_len;
 613         ber->ber_rwptr = NULL;
 614         return( ber->ber_tag );
 615 }
 616
 617 Sockbuf *lber_sockbuf_alloc( void )
 618 {
 619         Sockbuf *sb = calloc(1, sizeof(Sockbuf));
 620         sb->sb_debug = lber_int_debug;
 621         return sb;
 622 }
 623
 624 Sockbuf *lber_sockbuf_alloc_fd( int fd )
 625 {
 626         Sockbuf *sb = lber_sockbuf_alloc();
 627         sb->sb_sd = fd;
 628
 629         return sb;
 630 }
 631
 632 void lber_sockbuf_free( Sockbuf *sb )
 633 {
 634         if(sb == NULL) return;
 635
 636         free(sb);
 637 }
 638
 639 int lber_sockbuf_get_option( Sockbuf *sb, int opt, void *outvalue )
 640 {
 641         return LBER_OPT_ERROR;
 642 }
 643
 644 int lber_sockbuf_set_option( Sockbuf *sb, int opt, void *invalue )
 645 {
 646         return LBER_OPT_ERROR;
 647 }