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