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

   1 /* io.c - ber general i/o routines */
   2 /* $OpenLDAP$ */
   3 /*
   4  * Copyright 1998-2003 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 #include "ldap_log.h"
  37
  38 ber_slen_t
  39 ber_read(
  40         BerElement *ber,
  41         char *buf,
  42         ber_len_t len )
  43 {
  44         ber_len_t       actuallen, nleft;
  45
  46         assert( ber != NULL );
  47         assert( buf != NULL );
  48
  49         assert( LBER_VALID( ber ) );
  50
  51         nleft = ber_pvt_ber_remaining( ber );
  52         actuallen = nleft < len ? nleft : len;
  53
  54         AC_MEMCPY( buf, ber->ber_ptr, actuallen );
  55
  56         ber->ber_ptr += actuallen;
  57
  58         return( (ber_slen_t) actuallen );
  59 }
  60
  61 ber_slen_t
  62 ber_write(
  63         BerElement *ber,
  64         LDAP_CONST char *buf,
  65         ber_len_t len,
  66         int nosos )
  67 {
  68         assert( ber != NULL );
  69         assert( buf != NULL );
  70
  71         assert( LBER_VALID( ber ) );
  72
  73         if ( nosos || ber->ber_sos == NULL ) {
  74                 if ( ber->ber_ptr + len > ber->ber_end ) {
  75                         if ( ber_realloc( ber, len ) != 0 )
  76                                 return( -1 );
  77                 }
  78                 AC_MEMCPY( ber->ber_ptr, buf, (size_t)len );
  79                 ber->ber_ptr += len;
  80                 return( (ber_slen_t) len );
  81
  82         } else {
  83                 if ( ber->ber_sos->sos_ptr + len > ber->ber_end ) {
  84                         if ( ber_realloc( ber, len ) != 0 )
  85                                 return( -1 );
  86                 }
  87                 AC_MEMCPY( ber->ber_sos->sos_ptr, buf, (size_t)len );
  88                 ber->ber_sos->sos_ptr += len;
  89                 ber->ber_sos->sos_clen += len;
  90                 return( (ber_slen_t) len );
  91         }
  92 }
  93
  94 int
  95 ber_realloc( BerElement *ber, ber_len_t len )
  96 {
  97         ber_len_t       total;
  98         Seqorset        *s;
  99         long            off;
 100         char            *oldbuf;
 101
 102         assert( ber != NULL );
 103         assert( len > 0 );
 104         assert( LBER_VALID( ber ) );
 105
 106         total = ber_pvt_ber_total( ber );
 107
 108 #define LBER_EXBUFSIZ   4060 /* a few words less than 2^N for binary buddy */
 109 #if defined( LBER_EXBUFSIZ ) && LBER_EXBUFSIZ > 0
 110 # ifndef notdef
 111         /* don't realloc by small amounts */
 112         total += len < LBER_EXBUFSIZ ? LBER_EXBUFSIZ : len;
 113 # else
 114         {       /* not sure what value this adds */
 115                 ber_len_t have = (total + (LBER_EXBUFSIZE - 1)) / LBER_EXBUFSIZ;
 116                 ber_len_t need = (len + (LBER_EXBUFSIZ - 1)) / LBER_EXBUFSIZ;
 117                 total = ( have + need ) * LBER_EXBUFSIZ;
 118         }
 119 # endif
 120 #else
 121         total += len;   /* realloc just what's needed */
 122 #endif
 123
 124         oldbuf = ber->ber_buf;
 125
 126         ber->ber_buf = (char *) LBER_REALLOC( oldbuf, total );
 127
 128         if ( ber->ber_buf == NULL ) {
 129                 ber->ber_buf = oldbuf;
 130                 return( -1 );
 131         }
 132
 133         ber->ber_end = ber->ber_buf + total;
 134
 135         /*
 136          * If the stinking thing was moved, we need to go through and
 137          * reset all the sos and ber pointers.  Offsets would've been
 138          * a better idea... oh well.
 139          */
 140
 141         if ( ber->ber_buf != oldbuf ) {
 142                 ber->ber_ptr = ber->ber_buf + (ber->ber_ptr - oldbuf);
 143
 144                 for ( s = ber->ber_sos; s != NULL; s = s->sos_next ) {
 145                         off = s->sos_first - oldbuf;
 146                         s->sos_first = ber->ber_buf + off;
 147
 148                         off = s->sos_ptr - oldbuf;
 149                         s->sos_ptr = ber->ber_buf + off;
 150                 }
 151         }
 152
 153         return( 0 );
 154 }
 155
 156 void
 157 ber_free_buf( BerElement *ber )
 158 {
 159         Seqorset *s, *next;
 160
 161         assert( LBER_VALID( ber ) );
 162
 163         if ( ber->ber_buf) LBER_FREE( ber->ber_buf );
 164
 165         for( s = ber->ber_sos ; s != NULL ; s = next ) {
 166                 next = s->sos_next;
 167                 LBER_FREE( s );
 168         }
 169
 170         ber->ber_buf = NULL;
 171         ber->ber_sos = NULL;
 172         ber->ber_valid = LBER_UNINITIALIZED;
 173 }
 174
 175 void
 176 ber_free( BerElement *ber, int freebuf )
 177 {
 178 #ifdef LDAP_MEMORY_DEBUG
 179         assert( ber != NULL );
 180 #endif
 181
 182         if( ber == NULL ) {
 183                 return;
 184         }
 185
 186         if( freebuf )
 187                 ber_free_buf( ber );
 188
 189         LBER_FREE( (char *) ber );
 190 }
 191
 192 int
 193 ber_flush( Sockbuf *sb, BerElement *ber, int freeit )
 194 {
 195         ber_len_t       towrite;
 196         ber_slen_t      rc;
 197
 198         assert( sb != NULL );
 199         assert( ber != NULL );
 200
 201         assert( SOCKBUF_VALID( sb ) );
 202         assert( LBER_VALID( ber ) );
 203
 204         if ( ber->ber_rwptr == NULL ) {
 205                 ber->ber_rwptr = ber->ber_buf;
 206         }
 207         towrite = ber->ber_ptr - ber->ber_rwptr;
 208
 209         if ( sb->sb_debug ) {
 210 #ifdef NEW_LOGGING
 211                 LDAP_LOG( BER, DETAIL1,
 212                            "ber_flush: %ld bytes to sd %ld%s\n",
 213                            towrite, (long)sb->sb_fd,
 214                            ber->ber_rwptr != ber->ber_buf ? " (re-flush)" : "" );
 215
 216                 if(LDAP_LOGS_TEST(BER, DETAIL2))
 217                                 BER_DUMP(( "liblber", LDAP_LEVEL_DETAIL2, ber, 1 ));
 218
 219 #else
 220                 ber_log_printf( LDAP_DEBUG_TRACE, sb->sb_debug,
 221                         "ber_flush: %ld bytes to sd %ld%s\n",
 222                         towrite, (long) sb->sb_fd,
 223                         ber->ber_rwptr != ber->ber_buf ?  " (re-flush)" : "" );
 224                 ber_log_bprint( LDAP_DEBUG_PACKETS, sb->sb_debug,
 225                         ber->ber_rwptr, towrite );
 226 #endif
 227         }
 228
 229         while ( towrite > 0 ) {
 230 #ifdef LBER_TRICKLE
 231                 sleep(1);
 232                 rc = ber_int_sb_write( sb, ber->ber_rwptr, 1 );
 233 #else
 234                 rc = ber_int_sb_write( sb, ber->ber_rwptr, towrite );
 235 #endif
 236                 if (rc<=0) {
 237                         return -1;
 238                 }
 239                 towrite -= rc;
 240                 ber->ber_rwptr += rc;
 241         }
 242
 243         if ( freeit )
 244                 ber_free( ber, 1 );
 245
 246         return( 0 );
 247 }
 248
 249 BerElement *
 250 ber_alloc_t( int options )
 251 {
 252         BerElement      *ber;
 253
 254     ber_int_options.lbo_valid = LBER_INITIALIZED;
 255
 256         ber = (BerElement *) LBER_CALLOC( 1, sizeof(BerElement) );
 257
 258         if ( ber == NULL ) {
 259                 return NULL;
 260         }
 261
 262         ber->ber_valid = LBER_VALID_BERELEMENT;
 263         ber->ber_tag = LBER_DEFAULT;
 264         ber->ber_options = options;
 265         ber->ber_debug = ber_int_debug;
 266
 267         assert( LBER_VALID( ber ) );
 268         return ber;
 269 }
 270
 271 BerElement *
 272 ber_alloc( void )       /* deprecated */
 273 {
 274         return ber_alloc_t( 0 );
 275 }
 276
 277 BerElement *
 278 der_alloc( void )       /* deprecated */
 279 {
 280         return ber_alloc_t( LBER_USE_DER );
 281 }
 282
 283 BerElement *
 284 ber_dup( BerElement *ber )
 285 {
 286         BerElement      *new;
 287
 288         assert( ber != NULL );
 289         assert( LBER_VALID( ber ) );
 290
 291         if ( (new = ber_alloc_t( ber->ber_options )) == NULL ) {
 292                 return NULL;
 293         }
 294
 295         *new = *ber;
 296
 297         assert( LBER_VALID( new ) );
 298         return( new );
 299 }
 300
 301
 302 void
 303 ber_init2( BerElement *ber, struct berval *bv, int options )
 304 {
 305         assert( ber != NULL );
 306
 307         ber_int_options.lbo_valid = LBER_INITIALIZED;
 308
 309         (void) memset( (char *)ber, '\0', sizeof( BerElement ));
 310         ber->ber_valid = LBER_VALID_BERELEMENT;
 311         ber->ber_tag = LBER_DEFAULT;
 312         ber->ber_options = (char) options;
 313         ber->ber_debug = ber_int_debug;
 314
 315         if ( bv != NULL ) {
 316                 ber->ber_buf = bv->bv_val;
 317                 ber->ber_ptr = ber->ber_buf;
 318                 ber->ber_end = ber->ber_buf + bv->bv_len;
 319         }
 320
 321         assert( LBER_VALID( ber ) );
 322 }
 323
 324 /* OLD U-Mich ber_init() */
 325 void
 326 ber_init_w_nullc( BerElement *ber, int options )
 327 {
 328         ber_init2( ber, NULL, options );
 329 }
 330
 331 /* New C-API ber_init() */
 332 /* This function constructs a BerElement containing a copy
 333 ** of the data in the bv argument.
 334 */
 335 BerElement *
 336 ber_init( struct berval *bv )
 337 {
 338         BerElement *ber;
 339
 340         assert( bv != NULL );
 341
 342     ber_int_options.lbo_valid = LBER_INITIALIZED;
 343
 344         if ( bv == NULL ) {
 345                 return NULL;
 346         }
 347
 348         ber = ber_alloc_t( 0 );
 349
 350         if( ber == NULL ) {
 351                 /* allocation failed */
 352                 return NULL;
 353         }
 354
 355         /* copy the data */
 356         if ( ((ber_len_t) ber_write ( ber, bv->bv_val, bv->bv_len, 0 ))
 357                 != bv->bv_len )
 358         {
 359                 /* write failed, so free and return NULL */
 360                 ber_free( ber, 1 );
 361                 return NULL;
 362         }
 363
 364         ber_reset( ber, 1 );    /* reset the pointer to the start of the buffer */
 365         return ber;
 366 }
 367
 368 /* New C-API ber_flatten routine */
 369 /* This routine allocates a struct berval whose contents are a BER
 370 ** encoding taken from the ber argument.  The bvPtr pointer points to
 371 ** the returned berval.
 372 **
 373 ** ber_flatten2 is the same, but uses a struct berval passed by
 374 ** the caller. If alloc is 0 the returned bv uses the ber buf directly.
 375 */
 376 int ber_flatten2(
 377         BerElement *ber,
 378         struct berval *bv,
 379         int alloc )
 380 {
 381         assert( bv != NULL );
 382
 383         ber_int_options.lbo_valid = LBER_INITIALIZED;
 384
 385         if ( bv == NULL ) {
 386                 return -1;
 387         }
 388
 389         if ( ber == NULL ) {
 390                 /* ber is null, create an empty berval */
 391                 bv->bv_val = NULL;
 392                 bv->bv_len = 0;
 393
 394         } else {
 395                 /* copy the berval */
 396                 ber_len_t len = ber_pvt_ber_write( ber );
 397
 398                 if ( alloc ) {
 399                         bv->bv_val = (char *) LBER_MALLOC( len + 1 );
 400                         if ( bv->bv_val == NULL ) {
 401                                 return -1;
 402                         }
 403                         AC_MEMCPY( bv->bv_val, ber->ber_buf, len );
 404                 } else {
 405                         bv->bv_val = ber->ber_buf;
 406                 }
 407                 bv->bv_val[len] = '\0';
 408                 bv->bv_len = len;
 409         }
 410         return 0;
 411 }
 412
 413 int ber_flatten(
 414         BerElement *ber,
 415         struct berval **bvPtr)
 416 {
 417         struct berval *bv;
 418         int rc;
 419
 420         assert( bvPtr != NULL );
 421
 422         ber_int_options.lbo_valid = LBER_INITIALIZED;
 423
 424         if(bvPtr == NULL) {
 425                 return -1;
 426         }
 427
 428         bv = LBER_MALLOC( sizeof(struct berval) );
 429         if ( bv == NULL ) {
 430                 return -1;
 431         }
 432         rc = ber_flatten2(ber, bv, 1);
 433         if (rc == -1) {
 434                 LBER_FREE(bv);
 435         } else {
 436                 *bvPtr = bv;
 437         }
 438         return rc;
 439 }
 440
 441 void
 442 ber_reset( BerElement *ber, int was_writing )
 443 {
 444         assert( ber != NULL );
 445         assert( LBER_VALID( ber ) );
 446
 447         if ( was_writing ) {
 448                 ber->ber_end = ber->ber_ptr;
 449                 ber->ber_ptr = ber->ber_buf;
 450
 451         } else {
 452                 ber->ber_ptr = ber->ber_end;
 453         }
 454
 455         ber->ber_rwptr = NULL;
 456 }
 457
 458 /*
 459  * A rewrite of ber_get_next that can safely be called multiple times
 460  * for the same packet. It will simply continue where it stopped until
 461  * a full packet is read.
 462  */
 463
 464 #define LENSIZE 4
 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( LBER_VALID( ber ) );
 478
 479 #ifdef NEW_LOGGING
 480         LDAP_LOG( BER, ENTRY, "ber_get_next: enter\n", 0, 0, 0 );
 481 #else
 482         ber_log_printf( LDAP_DEBUG_TRACE, ber->ber_debug,
 483                 "ber_get_next\n" );
 484 #endif
 485
 486         /*
 487          * Any ber element looks like this: tag length contents.
 488          * Assuming everything's ok, we return the tag byte (we
 489          * can assume a single byte), return the length in len,
 490          * and the rest of the undecoded element in buf.
 491          *
 492          * Assumptions:
 493          *      1) small tags (less than 128)
 494          *      2) definite lengths
 495          *      3) primitive encodings used whenever possible
 496          *
 497          * The code also handles multi-byte tags. The first few bytes
 498          * of the message are read to check for multi-byte tags and
 499          * lengths. These bytes are temporarily stored in the ber_tag,
 500          * ber_len, and ber_usertag fields of the berelement until
 501          * tag/len parsing is complete. After this parsing, any leftover
 502          * bytes and the rest of the message are copied into the ber_buf.
 503          *
 504          * We expect tag and len to be at most 32 bits wide.
 505          */
 506
 507         if (ber->ber_rwptr == NULL) {
 508                 assert( ber->ber_buf == NULL );
 509                 ber->ber_rwptr = (char *) &ber->ber_len-1;
 510                 ber->ber_ptr = ber->ber_rwptr;
 511                 ber->ber_tag = 0;
 512         }
 513
 514         while (ber->ber_rwptr > (char *)&ber->ber_tag && ber->ber_rwptr <
 515                 (char *)&ber->ber_len + LENSIZE*2 -1) {
 516                 ber_slen_t sblen;
 517                 char buf[sizeof(ber->ber_len)-1];
 518                 ber_len_t tlen = 0;
 519
 520                 errno = 0;
 521                 sblen=ber_int_sb_read( sb, ber->ber_rwptr,
 522                         ((char *)&ber->ber_len + LENSIZE*2 - 1)-ber->ber_rwptr);
 523                 if (sblen<=0) return LBER_DEFAULT;
 524                 ber->ber_rwptr += sblen;
 525
 526                 /* We got at least one byte, try to parse the tag. */
 527                 if (ber->ber_ptr == (char *)&ber->ber_len-1) {
 528                         ber_tag_t tag;
 529                         unsigned char *p = (unsigned char *)ber->ber_ptr;
 530                         tag = *p++;
 531                         if ((tag & LBER_BIG_TAG_MASK) == LBER_BIG_TAG_MASK) {
 532                                 ber_len_t i;
 533                                 for (i=1; (char *)p<ber->ber_rwptr; i++) {
 534                                         tag <<= 8;
 535                                         tag |= *p++;
 536                                         if (!(tag & LBER_MORE_TAG_MASK))
 537                                                 break;
 538                                         /* Is the tag too big? */
 539                                         if (i == sizeof(ber_tag_t)-1) {
 540                                                 errno = ERANGE;
 541                                                 return LBER_DEFAULT;
 542                                         }
 543                                 }
 544                                 /* Did we run out of bytes? */
 545                                 if ((char *)p == ber->ber_rwptr) {
 546 #if defined( EWOULDBLOCK )
 547                                         errno = EWOULDBLOCK;
 548 #elif defined( EAGAIN )
 549                                         errno = EAGAIN;
 550 #endif
 551                                         return LBER_DEFAULT;
 552                                 }
 553                         }
 554                         ber->ber_tag = tag;
 555                         ber->ber_ptr = (char *)p;
 556                 }
 557
 558                 if ( ber->ber_ptr == ber->ber_rwptr ) {
 559 #if defined( EWOULDBLOCK )
 560                         errno = EWOULDBLOCK;
 561 #elif defined( EAGAIN )
 562                         errno = EAGAIN;
 563 #endif
 564                         return LBER_DEFAULT;
 565                 }
 566
 567                 /* Now look for the length */
 568                 if (*ber->ber_ptr & 0x80) {     /* multi-byte */
 569                         ber_len_t i;
 570                         unsigned char *p = (unsigned char *)ber->ber_ptr;
 571                         int llen = *p++ & 0x7f;
 572                         if (llen > (int)sizeof(ber_len_t)) {
 573                                 errno = ERANGE;
 574                                 return LBER_DEFAULT;
 575                         }
 576                         /* Not enough bytes? */
 577                         if (ber->ber_rwptr - (char *)p < llen) {
 578 #if defined( EWOULDBLOCK )
 579                                 errno = EWOULDBLOCK;
 580 #elif defined( EAGAIN )
 581                                 errno = EAGAIN;
 582 #endif
 583                                 return LBER_DEFAULT;
 584                         }
 585                         for (i=0; i<llen; i++)
 586                         {
 587                                 tlen <<=8;
 588                                 tlen |= *p++;
 589                         }
 590                         ber->ber_ptr = p;
 591                 } else {
 592                         tlen = *(unsigned char *)ber->ber_ptr++;
 593                 }
 594
 595                 /* Are there leftover data bytes inside ber->ber_len? */
 596                 if (ber->ber_ptr < (char *)&ber->ber_usertag) {
 597                         if (ber->ber_rwptr < (char *)&ber->ber_usertag)
 598                                 sblen = ber->ber_rwptr - ber->ber_ptr;
 599                         else
 600                                 sblen = (char *)&ber->ber_usertag - ber->ber_ptr;
 601                         AC_MEMCPY(buf, ber->ber_ptr, sblen);
 602                         ber->ber_ptr += sblen;
 603                 } else {
 604                         sblen = 0;
 605                 }
 606                 ber->ber_len = tlen;
 607
 608                 /* now fill the buffer. */
 609
 610                 /* make sure length is reasonable */
 611                 if ( ber->ber_len == 0 ) {
 612                         errno = ERANGE;
 613                         return LBER_DEFAULT;
 614                 }
 615
 616                 if ( sb->sb_max_incoming && ber->ber_len > sb->sb_max_incoming ) {
 617 #ifdef NEW_LOGGING
 618                         LDAP_LOG( BER, ERR,
 619                                 "ber_get_next: sockbuf_max_incoming limit hit "
 620                                 "(%d > %d)\n", ber->ber_len, sb->sb_max_incoming, 0 );
 621 #else
 622                         ber_log_printf( LDAP_DEBUG_CONNS, ber->ber_debug,
 623                                 "ber_get_next: sockbuf_max_incoming limit hit "
 624                                 "(%ld > %ld)\n", ber->ber_len, sb->sb_max_incoming );
 625 #endif
 626                         errno = ERANGE;
 627                         return LBER_DEFAULT;
 628                 }
 629
 630                 if (ber->ber_buf==NULL) {
 631                         ber_len_t l = ber->ber_rwptr - ber->ber_ptr;
 632                         /* ber->ber_ptr is always <= ber->ber->ber_rwptr.
 633                          * make sure ber->ber_len agrees with what we've
 634                          * already read.
 635                          */
 636                         if ( ber->ber_len < sblen + l ) {
 637                                 errno = ERANGE;
 638                                 return LBER_DEFAULT;
 639                         }
 640                         ber->ber_buf = (char *) LBER_MALLOC( ber->ber_len + 1 );
 641                         if (ber->ber_buf==NULL) {
 642                                 return LBER_DEFAULT;
 643                         }
 644                         ber->ber_end = ber->ber_buf + ber->ber_len;
 645                         if (sblen) {
 646                                 AC_MEMCPY(ber->ber_buf, buf, sblen);
 647                         }
 648                         if (l > 0) {
 649                                 AC_MEMCPY(ber->ber_buf + sblen, ber->ber_ptr, l);
 650                                 sblen += l;
 651                         }
 652                         ber->ber_ptr = ber->ber_buf;
 653                         ber->ber_usertag = 0;
 654                         if ((ber_len_t)sblen == ber->ber_len) {
 655                                 goto done;
 656                         }
 657                         ber->ber_rwptr = ber->ber_buf + sblen;
 658                 }
 659         }
 660
 661         if ((ber->ber_rwptr>=ber->ber_buf) && (ber->ber_rwptr<ber->ber_end)) {
 662                 ber_slen_t res;
 663                 ber_slen_t to_go;
 664
 665                 to_go = ber->ber_end - ber->ber_rwptr;
 666                 assert( to_go > 0 );
 667
 668                 errno = 0;
 669                 res = ber_int_sb_read( sb, ber->ber_rwptr, to_go );
 670                 if (res<=0) return LBER_DEFAULT;
 671                 ber->ber_rwptr+=res;
 672
 673                 if (res<to_go) {
 674 #if defined( EWOULDBLOCK )
 675                         errno = EWOULDBLOCK;
 676 #elif defined( EAGAIN )
 677                         errno = EAGAIN;
 678 #endif
 679                         return LBER_DEFAULT;
 680                 }
 681 done:
 682                 ber->ber_rwptr = NULL;
 683                 *len = ber->ber_len;
 684                 if ( ber->ber_debug ) {
 685 #ifdef NEW_LOGGING
 686                         LDAP_LOG( BER, DETAIL1,
 687                                 "ber_get_next: tag 0x%lx len %ld\n",
 688                                 ber->ber_tag, ber->ber_len, 0  );
 689                         if(LDAP_LOGS_TEST(BER, DETAIL2))
 690                                         BER_DUMP(( "liblber", LDAP_LEVEL_DETAIL2, ber, 1 ));
 691 #else
 692                         ber_log_printf( LDAP_DEBUG_TRACE, ber->ber_debug,
 693                                 "ber_get_next: tag 0x%lx len %ld contents:\n",
 694                                 ber->ber_tag, ber->ber_len );
 695                         ber_log_dump( LDAP_DEBUG_BER, ber->ber_debug, ber, 1 );
 696 #endif
 697                 }
 698                 return (ber->ber_tag);
 699         }
 700
 701         assert( 0 ); /* ber structure is messed up ?*/
 702         return LBER_DEFAULT;
 703 }