X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=libraries%2Fliblber%2Fio.c;h=a85f081aa49aba5627a2cf53452c911da6b48959;hb=ae471f78c32d7531c729aa88116b8b413cc200bf;hp=23fd80cbf41e6d44d105947764964d6eec16ed58;hpb=4298f5d991137266f9162c2a3e0764232c31e557;p=openldap diff --git a/libraries/liblber/io.c b/libraries/liblber/io.c index 23fd80cbf4..a85f081aa4 100644 --- a/libraries/liblber/io.c +++ b/libraries/liblber/io.c @@ -1,11 +1,19 @@ /* io.c - ber general i/o routines */ /* $OpenLDAP$ */ -/* - * Copyright 1998-2002 The OpenLDAP Foundation, All Rights Reserved. - * COPYING RESTRICTIONS APPLY, see COPYRIGHT file +/* This work is part of OpenLDAP Software . + * + * Copyright 1998-2008 The OpenLDAP Foundation. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted only as authorized by the OpenLDAP + * Public License. + * + * A copy of this license is available in the file LICENSE in the + * top-level directory of the distribution or, alternatively, at + * . */ -/* Portions - * Copyright (c) 1990 Regents of the University of Michigan. +/* Portions Copyright (c) 1990 Regents of the University of Michigan. * All rights reserved. * * Redistribution and use in source and binary forms are permitted @@ -15,6 +23,10 @@ * software without specific prior written permission. This software * is provided ``as is'' without express or implied warranty. */ +/* ACKNOWLEDGEMENTS: + * This work was originally developed by the University of Michigan + * (as part of U-MICH LDAP). + */ #include "portable.h" @@ -33,6 +45,26 @@ #endif #include "lber-int.h" +#include "ldap_log.h" + +ber_slen_t +ber_skip_data( + BerElement *ber, + ber_len_t len ) +{ + ber_len_t actuallen, nleft; + + assert( ber != NULL ); + + assert( LBER_VALID( ber ) ); + + nleft = ber_pvt_ber_remaining( ber ); + actuallen = nleft < len ? nleft : len; + ber->ber_ptr += actuallen; + ber->ber_tag = *(unsigned char *)ber->ber_ptr; + + return( (ber_slen_t) actuallen ); +} ber_slen_t ber_read( @@ -71,8 +103,7 @@ ber_write( if ( nosos || ber->ber_sos == NULL ) { if ( ber->ber_ptr + len > ber->ber_end ) { - if ( ber_realloc( ber, len ) != 0 ) - return( -1 ); + if ( ber_realloc( ber, len ) != 0 ) return( -1 ); } AC_MEMCPY( ber->ber_ptr, buf, (size_t)len ); ber->ber_ptr += len; @@ -80,8 +111,7 @@ ber_write( } else { if ( ber->ber_sos->sos_ptr + len > ber->ber_end ) { - if ( ber_realloc( ber, len ) != 0 ) - return( -1 ); + if ( ber_realloc( ber, len ) != 0 ) return( -1 ); } AC_MEMCPY( ber->ber_sos->sos_ptr, buf, (size_t)len ); ber->ber_sos->sos_ptr += len; @@ -104,7 +134,7 @@ ber_realloc( BerElement *ber, ber_len_t len ) total = ber_pvt_ber_total( ber ); -#define LBER_EXBUFSIZ 1000 /* a few words less than 2^N for binary buddy */ +#define LBER_EXBUFSIZ 4060 /* a few words less than 2^N for binary buddy */ #if defined( LBER_EXBUFSIZ ) && LBER_EXBUFSIZ > 0 # ifndef notdef /* don't realloc by small amounts */ @@ -122,7 +152,7 @@ ber_realloc( BerElement *ber, ber_len_t len ) oldbuf = ber->ber_buf; - ber->ber_buf = (char *) LBER_REALLOC( oldbuf, total ); + ber->ber_buf = (char *) ber_memrealloc_x( oldbuf, total, ber->ber_memctx ); if ( ber->ber_buf == NULL ) { ber->ber_buf = oldbuf; @@ -159,11 +189,11 @@ ber_free_buf( BerElement *ber ) assert( LBER_VALID( ber ) ); - if ( ber->ber_buf) LBER_FREE( ber->ber_buf ); + if ( ber->ber_buf) ber_memfree_x( ber->ber_buf, ber->ber_memctx ); for( s = ber->ber_sos ; s != NULL ; s = next ) { next = s->sos_next; - LBER_FREE( s ); + ber_memfree_x( s, ber->ber_memctx ); } ber->ber_buf = NULL; @@ -174,25 +204,29 @@ ber_free_buf( BerElement *ber ) void ber_free( BerElement *ber, int freebuf ) { -#ifdef LDAP_MEMORY_DEBUG - assert( ber != NULL ); -#endif - if( ber == NULL ) { + LDAP_MEMORY_DEBUG_ASSERT( ber != NULL ); return; } - if( freebuf ) - ber_free_buf( ber ); + if( freebuf ) ber_free_buf( ber ); - LBER_FREE( (char *) ber ); + ber_memfree_x( (char *) ber, ber->ber_memctx ); } int ber_flush( Sockbuf *sb, BerElement *ber, int freeit ) { - ber_len_t nwritten, towrite; - ber_slen_t rc; + return ber_flush2( sb, ber, + freeit ? LBER_FLUSH_FREE_ON_SUCCESS + : LBER_FLUSH_FREE_NEVER ); +} + +int +ber_flush2( Sockbuf *sb, BerElement *ber, int freeit ) +{ + ber_len_t towrite; + ber_slen_t rc; assert( sb != NULL ); assert( ber != NULL ); @@ -206,37 +240,32 @@ ber_flush( Sockbuf *sb, BerElement *ber, int freeit ) towrite = ber->ber_ptr - ber->ber_rwptr; if ( sb->sb_debug ) { -#ifdef NEW_LOGGING - LDAP_LOG(( "liblber", LDAP_LEVEL_DETAIL1, - "ber_flush: %ld bytes to sd %ld%s\n", - towrite, (long)sb->sb_fd, - ber->ber_rwptr != ber->ber_buf ? " (re-flush)" : "" )); - BER_DUMP(( "liblber", LDAP_LEVEL_DETAIL2, ber, 1 )); -#else - ber_log_printf( LDAP_DEBUG_ANY, sb->sb_debug, - "ber_flush: %ld bytes to sd %ld%s\n", + ber_log_printf( LDAP_DEBUG_TRACE, sb->sb_debug, + "ber_flush2: %ld bytes to sd %ld%s\n", towrite, (long) sb->sb_fd, ber->ber_rwptr != ber->ber_buf ? " (re-flush)" : "" ); ber_log_bprint( LDAP_DEBUG_PACKETS, sb->sb_debug, ber->ber_rwptr, towrite ); -#endif } - nwritten = 0; - do { + while ( towrite > 0 ) { +#ifdef LBER_TRICKLE + sleep(1); + rc = ber_int_sb_write( sb, ber->ber_rwptr, 1 ); +#else rc = ber_int_sb_write( sb, ber->ber_rwptr, towrite ); - if (rc<=0) { +#endif + if ( rc <= 0 ) { + if ( freeit & LBER_FLUSH_FREE_ON_ERROR ) ber_free( ber, 1 ); return -1; } towrite -= rc; - nwritten += rc; ber->ber_rwptr += rc; - } while ( towrite > 0 ); + } - if ( freeit ) - ber_free( ber, 1 ); + if ( freeit & LBER_FLUSH_FREE_ON_SUCCESS ) ber_free( ber, 1 ); - return( 0 ); + return 0; } BerElement * @@ -244,8 +273,6 @@ ber_alloc_t( int options ) { BerElement *ber; - ber_int_options.lbo_valid = LBER_INITIALIZED; - ber = (BerElement *) LBER_CALLOC( 1, sizeof(BerElement) ); if ( ber == NULL ) { @@ -292,23 +319,33 @@ ber_dup( BerElement *ber ) } -/* OLD U-Mich ber_init() */ void -ber_init_w_nullc( BerElement *ber, int options ) +ber_init2( BerElement *ber, struct berval *bv, int options ) { assert( ber != NULL ); - ber_int_options.lbo_valid = LBER_INITIALIZED; - (void) memset( (char *)ber, '\0', sizeof( BerElement )); ber->ber_valid = LBER_VALID_BERELEMENT; ber->ber_tag = LBER_DEFAULT; ber->ber_options = (char) options; ber->ber_debug = ber_int_debug; + if ( bv != NULL ) { + ber->ber_buf = bv->bv_val; + ber->ber_ptr = ber->ber_buf; + ber->ber_end = ber->ber_buf + bv->bv_len; + } + assert( LBER_VALID( ber ) ); } +/* OLD U-Mich ber_init() */ +void +ber_init_w_nullc( BerElement *ber, int options ) +{ + ber_init2( ber, NULL, options ); +} + /* New C-API ber_init() */ /* This function constructs a BerElement containing a copy ** of the data in the bv argument. @@ -320,8 +357,6 @@ ber_init( struct berval *bv ) assert( bv != NULL ); - ber_int_options.lbo_valid = LBER_INITIALIZED; - if ( bv == NULL ) { return NULL; } @@ -348,24 +383,19 @@ ber_init( struct berval *bv ) /* New C-API ber_flatten routine */ /* This routine allocates a struct berval whose contents are a BER -** encoding taken from the ber argument. The bvPtr pointer pointers to +** encoding taken from the ber argument. The bvPtr pointer points to ** the returned berval. +** +** ber_flatten2 is the same, but uses a struct berval passed by +** the caller. If alloc is 0 the returned bv uses the ber buf directly. */ -int ber_flatten( +int ber_flatten2( BerElement *ber, - struct berval **bvPtr) + struct berval *bv, + int alloc ) { - struct berval *bv; - - assert( bvPtr != NULL ); - - ber_int_options.lbo_valid = LBER_INITIALIZED; - - if(bvPtr == NULL) { - return -1; - } + assert( bv != NULL ); - bv = LBER_MALLOC( sizeof(struct berval) ); if ( bv == NULL ) { return -1; } @@ -379,21 +409,47 @@ int ber_flatten( /* copy the berval */ ber_len_t len = ber_pvt_ber_write( ber ); - bv->bv_val = (char *) LBER_MALLOC( len + 1 ); - if ( bv->bv_val == NULL ) { - LBER_FREE( bv ); - return -1; + if ( alloc ) { + bv->bv_val = (char *) ber_memalloc_x( len + 1, ber->ber_memctx ); + if ( bv->bv_val == NULL ) { + return -1; + } + AC_MEMCPY( bv->bv_val, ber->ber_buf, len ); + } else { + bv->bv_val = ber->ber_buf; } - - AC_MEMCPY( bv->bv_val, ber->ber_buf, len ); bv->bv_val[len] = '\0'; bv->bv_len = len; } - - *bvPtr = bv; return 0; } +int ber_flatten( + BerElement *ber, + struct berval **bvPtr) +{ + struct berval *bv; + int rc; + + assert( bvPtr != NULL ); + + if(bvPtr == NULL) { + return -1; + } + + bv = ber_memalloc_x( sizeof(struct berval), ber->ber_memctx ); + if ( bv == NULL ) { + return -1; + } + rc = ber_flatten2(ber, bv, 1); + if (rc == -1) { + ber_memfree_x(bv, ber->ber_memctx); + } else { + *bvPtr = bv; + } + return rc; +} + void ber_reset( BerElement *ber, int was_writing ) { @@ -417,6 +473,8 @@ ber_reset( BerElement *ber, int was_writing ) * a full packet is read. */ +#define LENSIZE 4 + ber_tag_t ber_get_next( Sockbuf *sb, @@ -430,12 +488,10 @@ ber_get_next( assert( SOCKBUF_VALID( sb ) ); assert( LBER_VALID( ber ) ); -#ifdef NEW_LOGGING - LDAP_LOG(( "liblber", LDAP_LEVEL_ENTRY, "ber_get_next: enter\n" )); -#else - ber_log_printf( LDAP_DEBUG_TRACE, ber->ber_debug, - "ber_get_next\n" ); -#endif + if ( ber->ber_debug & LDAP_DEBUG_TRACE ) { + ber_log_printf( LDAP_DEBUG_TRACE, ber->ber_debug, + "ber_get_next\n" ); + } /* * Any ber element looks like this: tag length contents. @@ -447,30 +503,35 @@ ber_get_next( * 1) small tags (less than 128) * 2) definite lengths * 3) primitive encodings used whenever possible + * + * The code also handles multi-byte tags. The first few bytes + * of the message are read to check for multi-byte tags and + * lengths. These bytes are temporarily stored in the ber_tag, + * ber_len, and ber_usertag fields of the berelement until + * tag/len parsing is complete. After this parsing, any leftover + * bytes and the rest of the message are copied into the ber_buf. + * + * We expect tag and len to be at most 32 bits wide. */ if (ber->ber_rwptr == NULL) { - /* XXYYZ - * dtest does like this assert. - */ - /* assert( ber->ber_buf == NULL ); */ + assert( ber->ber_buf == NULL ); ber->ber_rwptr = (char *) &ber->ber_len-1; ber->ber_ptr = ber->ber_rwptr; ber->ber_tag = 0; } while (ber->ber_rwptr > (char *)&ber->ber_tag && ber->ber_rwptr < - (char *)(&ber->ber_usertag + 1)) { - int i; + (char *)&ber->ber_len + LENSIZE*2 -1) { + ber_slen_t sblen; char buf[sizeof(ber->ber_len)-1]; ber_len_t tlen = 0; - if ((i=ber_int_sb_read( sb, ber->ber_rwptr, - (char *)(&ber->ber_usertag+1)-ber->ber_rwptr))<=0) { - return LBER_DEFAULT; - } - - ber->ber_rwptr += i; + sock_errset(0); + sblen=ber_int_sb_read( sb, ber->ber_rwptr, + ((char *)&ber->ber_len + LENSIZE*2 - 1)-ber->ber_rwptr); + if (sblen<=0) return LBER_DEFAULT; + ber->ber_rwptr += sblen; /* We got at least one byte, try to parse the tag. */ if (ber->ber_ptr == (char *)&ber->ber_len-1) { @@ -478,52 +539,79 @@ ber_get_next( unsigned char *p = (unsigned char *)ber->ber_ptr; tag = *p++; if ((tag & LBER_BIG_TAG_MASK) == LBER_BIG_TAG_MASK) { - for (i=1; (char *)pber_rwptr; i++,p++) { + ber_len_t i; + for (i=1; (char *)pber_rwptr; i++) { tag <<= 8; - tag |= *p; - if (!(*p & LBER_MORE_TAG_MASK)) + tag |= *p++; + if (!(tag & LBER_MORE_TAG_MASK)) break; /* Is the tag too big? */ if (i == sizeof(ber_tag_t)-1) { - errno = ERANGE; + sock_errset(ERANGE); return LBER_DEFAULT; } } /* Did we run out of bytes? */ if ((char *)p == ber->ber_rwptr) { +#if defined( EWOULDBLOCK ) + sock_errset(EWOULDBLOCK); +#elif defined( EAGAIN ) + sock_errset(EAGAIN); +#endif return LBER_DEFAULT; } - p++; } ber->ber_tag = tag; ber->ber_ptr = (char *)p; } + if ( ber->ber_ptr == ber->ber_rwptr ) { +#if defined( EWOULDBLOCK ) + sock_errset(EWOULDBLOCK); +#elif defined( EAGAIN ) + sock_errset(EAGAIN); +#endif + return LBER_DEFAULT; + } + /* Now look for the length */ if (*ber->ber_ptr & 0x80) { /* multi-byte */ - int llen = *(unsigned char *)ber->ber_ptr++ & 0x7f; - if (llen > sizeof(ber_len_t)) { - errno = ERANGE; + int i; + unsigned char *p = (unsigned char *)ber->ber_ptr; + int llen = *p++ & 0x7f; + if (llen > (int)sizeof(ber_len_t)) { + sock_errset(ERANGE); return LBER_DEFAULT; } /* Not enough bytes? */ - if (ber->ber_rwptr - ber->ber_ptr < llen) { + if (ber->ber_rwptr - (char *)p < llen) { +#if defined( EWOULDBLOCK ) + sock_errset(EWOULDBLOCK); +#elif defined( EAGAIN ) + sock_errset(EAGAIN); +#endif return LBER_DEFAULT; } - for (i=0; iber_ptrber_rwptr; i++,ber->ber_ptr++) { + for (i=0; iber_ptr; + tlen |= *p++; } + ber->ber_ptr = (char *)p; } else { tlen = *(unsigned char *)ber->ber_ptr++; } + /* Are there leftover data bytes inside ber->ber_len? */ if (ber->ber_ptr < (char *)&ber->ber_usertag) { - i = (char *)&ber->ber_usertag - ber->ber_ptr; - AC_MEMCPY(buf, ber->ber_ptr, i); - ber->ber_ptr += i; + if (ber->ber_rwptr < (char *)&ber->ber_usertag) { + sblen = ber->ber_rwptr - ber->ber_ptr; + } else { + sblen = (char *)&ber->ber_usertag - ber->ber_ptr; + } + AC_MEMCPY(buf, ber->ber_ptr, sblen); + ber->ber_ptr += sblen; } else { - i = 0; + sblen = 0; } ber->ber_len = tlen; @@ -531,42 +619,47 @@ ber_get_next( /* make sure length is reasonable */ if ( ber->ber_len == 0 ) { - errno = ERANGE; + sock_errset(ERANGE); return LBER_DEFAULT; - } else if ( sb->sb_max_incoming && ber->ber_len > sb->sb_max_incoming ) { -#ifdef NEW_LOGGING - LDAP_LOG(( "liblber", LDAP_LEVEL_ERR, - "ber_get_next: sockbuf_max_incoming limit hit " - "(%d > %d)\n", ber->ber_len, sb->sb_max_incoming )); -#else + } + + if ( sb->sb_max_incoming && ber->ber_len > sb->sb_max_incoming ) { ber_log_printf( LDAP_DEBUG_CONNS, ber->ber_debug, - "ber_get_next: sockbuf_max_incoming limit hit " + "ber_get_next: sockbuf_max_incoming exceeded " "(%ld > %ld)\n", ber->ber_len, sb->sb_max_incoming ); -#endif - errno = ERANGE; + sock_errset(ERANGE); return LBER_DEFAULT; } if (ber->ber_buf==NULL) { - ber->ber_buf = (char *) LBER_MALLOC( ber->ber_len + 1 ); + ber_len_t l = ber->ber_rwptr - ber->ber_ptr; + /* ber->ber_ptr is always <= ber->ber->ber_rwptr. + * make sure ber->ber_len agrees with what we've + * already read. + */ + if ( ber->ber_len < sblen + l ) { + sock_errset(ERANGE); + return LBER_DEFAULT; + } + ber->ber_buf = (char *) ber_memalloc_x( ber->ber_len + 1, ber->ber_memctx ); if (ber->ber_buf==NULL) { return LBER_DEFAULT; } ber->ber_end = ber->ber_buf + ber->ber_len; - if (i) { - AC_MEMCPY(ber->ber_buf, buf, i); + if (sblen) { + AC_MEMCPY(ber->ber_buf, buf, sblen); } - if (ber->ber_ptr < ber->ber_rwptr) { - AC_MEMCPY(ber->ber_buf + i, ber->ber_ptr, ber->ber_rwptr- - ber->ber_ptr); - i += ber->ber_rwptr - ber->ber_ptr; + if (l > 0) { + AC_MEMCPY(ber->ber_buf + sblen, ber->ber_ptr, l); + sblen += l; } + *ber->ber_end = '\0'; ber->ber_ptr = ber->ber_buf; ber->ber_usertag = 0; - if (i == ber->ber_len) { + if ((ber_len_t)sblen == ber->ber_len) { goto done; } - ber->ber_rwptr = ber->ber_buf + i; + ber->ber_rwptr = ber->ber_buf + sblen; } } @@ -577,16 +670,16 @@ ber_get_next( to_go = ber->ber_end - ber->ber_rwptr; assert( to_go > 0 ); + sock_errset(0); res = ber_int_sb_read( sb, ber->ber_rwptr, to_go ); - if (res<=0) - return LBER_DEFAULT; + if (res<=0) return LBER_DEFAULT; ber->ber_rwptr+=res; if (resber_rwptr = NULL; *len = ber->ber_len; if ( ber->ber_debug ) { -#ifdef NEW_LOGGING - LDAP_LOG(( "liblber", LDAP_LEVEL_DETAIL1, - "ber_get_next: tag 0x%lx len %ld\n", - ber->ber_tag, ber->ber_len )); - BER_DUMP(( "liblber", LDAP_LEVEL_DETAIL2, ber, 1 )); -#else ber_log_printf( LDAP_DEBUG_TRACE, ber->ber_debug, "ber_get_next: tag 0x%lx len %ld contents:\n", ber->ber_tag, ber->ber_len ); ber_log_dump( LDAP_DEBUG_BER, ber->ber_debug, ber, 1 ); -#endif } return (ber->ber_tag); } @@ -612,3 +698,36 @@ done: assert( 0 ); /* ber structure is messed up ?*/ return LBER_DEFAULT; } + +char * +ber_start( BerElement* ber ) +{ + return ber->ber_buf; +} + +int +ber_len( BerElement* ber ) +{ + return ( ber->ber_end - ber->ber_buf ); +} + +int +ber_ptrlen( BerElement* ber ) +{ + return ( ber->ber_ptr - ber->ber_buf ); +} + +void +ber_rewind ( BerElement * ber ) +{ + ber->ber_rwptr = NULL; + ber->ber_sos = NULL; + ber->ber_end = ber->ber_ptr; + ber->ber_ptr = ber->ber_buf; +} + +int +ber_remaining( BerElement * ber ) +{ + return ber_pvt_ber_remaining( ber ); +}