#define EXBUFSIZ 1024
+/* probably far too large... */
+#define MAX_BERBUFSIZE (128*1024)
+
+#if defined( DOS ) && !defined( _WIN32 ) && (MAX_BERBUFSIZE > 65535)
+# undef MAX_BERBUFSIZE
+# define MAX_BERBUFSIZE 65535
+#endif
+
static long
BerRead( Sockbuf *sb, char *buf, long len )
{
int c;
long nread = 0;
+ assert( sb != NULL );
+ assert( buf != NULL );
+
while ( len > 0 ) {
- if ( (c = lber_pvt_sb_read( sb, buf, len )) <= 0 ) {
+ if ( (c = ber_pvt_sb_read( sb, buf, len )) <= 0 ) {
if ( nread > 0 )
break;
return( c );
{
unsigned long actuallen, nleft;
+ assert( ber != NULL );
+ assert( buf != NULL );
+
nleft = ber->ber_end - ber->ber_ptr;
actuallen = nleft < len ? nleft : len;
}
long
-ber_write( BerElement *ber, char *buf, unsigned long len, int nosos )
+ber_write(
+ BerElement *ber,
+ LDAP_CONST char *buf,
+ unsigned long len,
+ int nosos )
{
+ assert( ber != NULL );
+ assert( buf != NULL );
+
if ( nosos || ber->ber_sos == NULL ) {
if ( ber->ber_ptr + len > ber->ber_end ) {
if ( ber_realloc( ber, len ) != 0 )
long off;
char *oldbuf;
+ assert( ber != NULL );
+ assert( len > 0 );
+
have = (ber->ber_end - ber->ber_buf) / EXBUFSIZ;
need = (len < EXBUFSIZ ? 1 : (len + (EXBUFSIZ - 1)) / EXBUFSIZ);
total = have * EXBUFSIZ + need * EXBUFSIZ;
void
ber_free( BerElement *ber, int freebuf )
{
+ assert( ber != NULL );
+
if ( freebuf && ber->ber_buf != NULL )
free( ber->ber_buf );
ber->ber_buf = NULL;
{
long nwritten, towrite, rc;
+ assert( sb != NULL );
+ assert( ber != NULL );
+
if ( ber->ber_rwptr == NULL ) {
ber->ber_rwptr = ber->ber_buf;
}
towrite = ber->ber_ptr - ber->ber_rwptr;
if ( sb->sb_debug ) {
- lber_log_printf( LDAP_DEBUG_ANY, sb->sb_debug,
+ ber_log_printf( LDAP_DEBUG_ANY, sb->sb_debug,
"ber_flush: %ld bytes to sd %ld%s\n", towrite,
(long) sb->sb_sd, ber->ber_rwptr != ber->ber_buf ? " (re-flush)"
: "" );
- lber_log_bprint( LDAP_DEBUG_PACKETS, sb->sb_debug,
+ ber_log_bprint( LDAP_DEBUG_PACKETS, sb->sb_debug,
ber->ber_rwptr, towrite );
}
nwritten = 0;
do {
- rc = lber_pvt_sb_write( sb, ber->ber_rwptr, towrite );
+ rc = ber_pvt_sb_write( sb, ber->ber_rwptr, towrite );
if (rc<=0) {
return -1;
}
{
BerElement *ber;
- if ( (ber = (BerElement *) calloc( 1, sizeof(BerElement) )) == NULLBER )
+ ber = (BerElement *) calloc( 1, sizeof(BerElement) );
+
+ if ( ber == NULLBER )
return( NULLBER );
+
ber->ber_tag = LBER_DEFAULT;
ber->ber_options = options;
- ber->ber_debug = lber_int_debug;
+ ber->ber_debug = ber_int_debug;
return( ber );
}
BerElement *
-ber_alloc( void )
+ber_alloc( void ) /* deprecated */
{
return( ber_alloc_t( 0 ) );
}
BerElement *
-der_alloc( void )
+der_alloc( void ) /* deprecated */
{
return( ber_alloc_t( LBER_USE_DER ) );
}
BerElement *
-ber_dup( BerElement *ber )
+ber_dup( LDAP_CONST BerElement *ber )
{
BerElement *new;
- if ( (new = ber_alloc()) == NULLBER )
- return( NULLBER );
+ assert( ber != NULL );
+
+ if ( (new = ber_alloc_t( ber->ber_options )) == NULL ) {
+ return( NULL );
+ }
*new = *ber;
void
ber_init_w_nullc( BerElement *ber, int options )
{
- (void) memset( (char *)ber, '\0', sizeof( BerElement )); /* ### Bug: Expects pointers to have 00000 bit pattern */
+ assert( ber != NULL );
+
+ (void) memset( (char *)ber, '\0', sizeof( BerElement ));
ber->ber_tag = LBER_DEFAULT;
ber->ber_options = (char) options;
+ ber->ber_debug = ber_int_debug;
}
/* New C-API ber_init() */
{
BerElement *ber;
+ assert( bv != NULL );
+
if ( bv == NULL ) {
return NULL;
}
** the returned berval.
*/
int ber_flatten(
- BerElement *ber,
+ LDAP_CONST BerElement *ber,
struct berval **bvPtr)
{
struct berval *bv;
+ assert( bvPtr != NULL );
+
if(bvPtr == NULL) {
return( -1 );
}
void
ber_reset( BerElement *ber, int was_writing )
{
+ assert( ber != NULL );
+
if ( was_writing ) {
ber->ber_end = ber->ber_ptr;
ber->ber_ptr = ber->ber_buf;
ber->ber_rwptr = NULL;
}
+#if 0
/* return the tag - LBER_DEFAULT returned means trouble */
static unsigned long
get_tag( Sockbuf *sb )
char *tagp;
unsigned int i;
- if ( lber_pvt_sb_read( sb, (char *) &xbyte, 1 ) != 1 )
+ assert( sb != NULL );
+
+ if ( ber_pvt_sb_read( sb, (char *) &xbyte, 1 ) != 1 )
return( LBER_DEFAULT );
if ( (xbyte & LBER_BIG_TAG_MASK) != LBER_BIG_TAG_MASK )
tagp = (char *) &tag;
tagp[0] = xbyte;
for ( i = 1; i < sizeof(long); i++ ) {
- if ( lber_pvt_sb_read( sb, (char *) &xbyte, 1 ) != 1 )
+ if ( ber_pvt_sb_read( sb, (char *) &xbyte, 1 ) != 1 )
return( LBER_DEFAULT );
tagp[i] = xbyte;
/* want leading, not trailing 0's */
return( tag >> (sizeof(long) - i - 1) );
}
+#endif
+
+/*
+ * A rewrite of ber_get_next that can safely be called multiple times
+ * for the same packet. It will simply continue were it stopped until
+ * a full packet is read.
+ */
unsigned long
ber_get_next( Sockbuf *sb, unsigned long *len, BerElement *ber )
{
- unsigned long tag = 0, netlen, toread;
- unsigned char lc;
- long rc;
- long noctets;
- unsigned int diff;
+ assert( sb != NULL );
+ assert( len != NULL );
+ assert( ber != NULL );
if ( ber->ber_debug ) {
- lber_log_printf( LDAP_DEBUG_TRACE, ber->ber_debug,
+ ber_log_printf( LDAP_DEBUG_TRACE, ber->ber_debug,
"ber_get_next\n" );
}
-
+
/*
* Any ber element looks like this: tag length contents.
* Assuming everything's ok, we return the tag byte (we
* 2) definite lengths
* 3) primitive encodings used whenever possible
*/
-
- /*
- * first time through - malloc the buffer, set up ptrs, and
- * read the tag and the length and as much of the rest as we can
- */
-
- if ( ber->ber_rwptr == NULL ) {
- /*
- * First, we read the tag.
- */
-
- if ( (tag = get_tag( sb )) == LBER_DEFAULT ) {
- return( LBER_DEFAULT );
- }
- ber->ber_tag = tag;
-
- /*
- * Next, read the length. The first byte contains the length
- * of the length. If bit 8 is set, the length is the long
- * form, otherwise it's the short form. We don't allow a
- * length that's greater than what we can hold in an unsigned
- * long.
+
+ if (ber->ber_rwptr == NULL) {
+ /* XXYYZ
+ * dtest does like this assert.
*/
+ /* assert( ber->ber_buf == NULL ); */
+ ber->ber_rwptr = (char *) &ber->ber_tag;
+ ber->ber_tag = 0;
+ }
- *len = netlen = 0;
- if ( lber_pvt_sb_read( sb, (char *) &lc, 1 ) != 1 ) {
- return( LBER_DEFAULT );
+#define PTR_IN_VAR( ptr, var )\
+(((ptr)>=(char *) &(var)) && ((ptr)< (char *) &(var)+sizeof(var)))
+
+ if (PTR_IN_VAR(ber->ber_rwptr, ber->ber_tag)) {
+ if (ber->ber_rwptr == (char *) &ber->ber_tag) {
+ if (ber_pvt_sb_read( sb, ber->ber_rwptr, 1)<=0)
+ return LBER_DEFAULT;
+ if ((ber->ber_rwptr[0] & LBER_BIG_TAG_MASK)
+ != LBER_BIG_TAG_MASK) {
+ ber->ber_tag = ber->ber_rwptr[0];
+ ber->ber_rwptr = (char *) &ber->ber_usertag;
+ goto get_lenbyte;
+ }
+ ber->ber_rwptr++;
}
- if ( lc & 0x80 ) {
- noctets = (lc & 0x7f);
- if ( noctets > sizeof(unsigned long) )
- return( LBER_DEFAULT );
- diff = sizeof(unsigned long) - noctets;
- if ( BerRead( sb, (char *) &netlen + diff, noctets ) !=
- noctets ) {
- return( LBER_DEFAULT );
+ do {
+ /* reading the tag... */
+ if (ber_pvt_sb_read( sb, ber->ber_rwptr, 1)<=0)
+ return LBER_DEFAULT;
+ if (! (ber->ber_rwptr[0] & LBER_MORE_TAG_MASK) ) {
+ ber->ber_tag>>=sizeof(ber->ber_tag) -
+ ((char *) &ber->ber_tag - ber->ber_rwptr);
+ ber->ber_rwptr = (char *) &ber->ber_usertag;
+ goto get_lenbyte;
}
- *len = AC_NTOHL( netlen );
+ } while (PTR_IN_VAR(ber->ber_rwptr,ber->ber_tag));
+ errno = ERANGE; /* this is a serious error. */
+ return LBER_DEFAULT;
+ }
+get_lenbyte:
+ if (ber->ber_rwptr==(char *) &ber->ber_usertag) {
+ unsigned char c;
+ if (ber_pvt_sb_read( sb, (char *) &c, 1)<=0)
+ return LBER_DEFAULT;
+ if (c & 0x80U) {
+ int len = c & 0x7fU;
+ if ( (len==0) || ((unsigned) len>sizeof( ber->ber_len ) ) ) {
+ errno = ERANGE;
+ return LBER_DEFAULT;
+ }
+ ber->ber_rwptr = (char *) &ber->ber_len +
+ sizeof(ber->ber_len) - len;
+ ber->ber_len = 0;
} else {
- *len = lc;
- }
- ber->ber_len = *len;
-
- /*
- * Finally, malloc a buffer for the contents and read it in.
- * It's this buffer that's passed to all the other ber decoding
- * routines.
- */
-
-#if defined( DOS ) && !defined( _WIN32 )
- if ( *len > 65535 ) { /* DOS can't allocate > 64K */
- return( LBER_DEFAULT );
+ ber->ber_len = c;
+ goto fill_buffer;
}
-#endif /* DOS && !_WIN32 */
-#ifdef DEADWOOD
- if ( ( sb->sb_options & LBER_MAX_INCOMING_SIZE ) &&
- *len > (unsigned long) sb->sb_max_incoming ) {
- return( LBER_DEFAULT );
+ }
+ if (PTR_IN_VAR(ber->ber_rwptr, ber->ber_len)) {
+ int res;
+ int to_go;
+ to_go = (char *) &ber->ber_len + sizeof( ber->ber_len ) -
+ ber->ber_rwptr;
+ assert( to_go > 0 );
+ res = ber_pvt_sb_read( sb, ber->ber_rwptr, to_go );
+ if (res <=0)
+ return LBER_DEFAULT;
+ ber->ber_rwptr += res;
+ if (res==to_go) {
+ /* convert length. */
+ ber->ber_len = AC_NTOHL( ber->ber_len );
+ goto fill_buffer;
+ } else {
+#if defined( EWOULDBLOCK )
+ errno = EWOULDBLOCK;
+#elif defined( EAGAIN )
+ errno = EAGAIN;
+#endif
+ return LBER_DEFAULT;
}
-#endif
- if ( (ber->ber_buf = (char *) malloc( (size_t)*len )) == NULL ) {
- return( LBER_DEFAULT );
+ }
+fill_buffer:
+ /* now fill the buffer. */
+ if (ber->ber_buf==NULL) {
+ if (ber->ber_len > MAX_BERBUFSIZE) {
+ errno = ERANGE;
+ return LBER_DEFAULT;
}
- ber->ber_ptr = ber->ber_buf;
- ber->ber_end = ber->ber_buf + *len;
+ ber->ber_buf = (char *) malloc( ber->ber_len );
+ if (ber->ber_buf==NULL)
+ return LBER_DEFAULT;
ber->ber_rwptr = ber->ber_buf;
+ ber->ber_ptr = ber->ber_buf;
+ ber->ber_end = ber->ber_buf + ber->ber_len;
}
-
- toread = (unsigned long)ber->ber_end - (unsigned long)ber->ber_rwptr;
- do {
- if ( (rc = lber_pvt_sb_read( sb, ber->ber_rwptr, (long)toread )) <= 0 ) {
- return( LBER_DEFAULT );
+ if ((ber->ber_rwptr>=ber->ber_buf) && (ber->ber_rwptr<ber->ber_end)) {
+ int res;
+ int to_go;
+
+ to_go = ber->ber_end - ber->ber_rwptr;
+ assert( to_go > 0 );
+
+ res = ber_pvt_sb_read( sb, ber->ber_rwptr, to_go );
+ if (res<=0)
+ return LBER_DEFAULT;
+ ber->ber_rwptr+=res;
+
+ if (res<to_go) {
+#if defined( EWOULDBLOCK )
+ errno = EWOULDBLOCK;
+#elif defined( EAGAIN )
+ errno = EAGAIN;
+#endif
+ return LBER_DEFAULT;
}
-
- toread -= rc;
- ber->ber_rwptr += rc;
- } while ( toread > 0 );
-
- if ( ber->ber_debug ) {
- lber_log_printf( LDAP_DEBUG_TRACE, ber->ber_debug,
- "ber_get_next: tag 0x%lx len %ld contents:\n",
- tag, ber->ber_len );
-
- lber_log_dump( LDAP_DEBUG_BER, ber->ber_debug, ber, 1 );
+
+ ber->ber_rwptr = NULL;
+ *len = ber->ber_len;
+ if ( ber->ber_debug ) {
+ 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 );
+ }
+ return (ber->ber_tag);
}
-
- *len = ber->ber_len;
- ber->ber_rwptr = NULL;
- return( ber->ber_tag );
-}
-
-Sockbuf *lber_pvt_sb_alloc( void )
-{
- Sockbuf *sb = calloc(1, sizeof(Sockbuf));
- lber_pvt_sb_init( sb );
- return sb;
+ assert( 0 ); /* ber structure is messed up ?*/
+ return LBER_DEFAULT;
}
-Sockbuf *lber_pvt_sb_alloc_fd( int fd )
+void ber_clear( BerElement *ber, int freebuf )
{
- Sockbuf *sb = lber_pvt_sb_alloc();
- lber_pvt_sb_set_desc( sb, fd );
- lber_pvt_sb_set_io( sb, &lber_pvt_sb_io_tcp, NULL );
- return sb;
-}
+ assert( ber != NULL );
-void lber_pvt_sb_free( Sockbuf *sb )
-{
- if(sb == NULL) return;
- lber_pvt_sb_destroy( sb );
- free(sb);
-}
-
-int lber_pvt_sb_get_option( Sockbuf *sb, int opt, void *outvalue )
-{
- return LBER_OPT_ERROR;
+ if ((freebuf) && (ber->ber_buf))
+ free( ber->ber_buf );
+ ber->ber_buf = NULL;
+ ber->ber_rwptr = NULL;
+ ber->ber_end = NULL;
}
-int lber_pvt_sb_set_option( Sockbuf *sb, int opt, void *invalue )
-{
- return LBER_OPT_ERROR;
-}
projects / openldap / blobdiff