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