X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=servers%2Fslapd%2Fentry.c;h=61749ad06b95b25d481d44b41ef3c7de69eb0090;hb=5094d6abda4a30b1cb42b1242260d2748de6159a;hp=0e99f108f3f30fb466ebc7d2e524316b3645a61f;hpb=0039cb2a37ad6ee7ec40b6e29e35698329476098;p=openldap diff --git a/servers/slapd/entry.c b/servers/slapd/entry.c index 0e99f108f3..61749ad06b 100644 --- a/servers/slapd/entry.c +++ b/servers/slapd/entry.c @@ -1,7 +1,7 @@ /* entry.c - routines for dealing with entries */ /* $OpenLDAP$ */ /* - * Copyright 1998-2000 The OpenLDAP Foundation, All Rights Reserved. + * Copyright 1998-2003 The OpenLDAP Foundation, All Rights Reserved. * COPYING RESTRICTIONS APPLY, see COPYRIGHT file */ @@ -24,11 +24,13 @@ static int emaxsize;/* max size of ebuf */ /* * Empty root entry */ -const Entry slap_entry_root = { NOID, { 0, "" }, { 0, "" }, NULL, NULL }; +const Entry slap_entry_root = { + NOID, { 0, "" }, { 0, "" }, NULL, 0, { 0, "" }, NULL +}; int entry_destroy(void) { - free( ebuf ); + if ( ebuf ) free( ebuf ); ebuf = NULL; ecur = NULL; emaxsize = 0; @@ -42,8 +44,8 @@ str2entry( char *s ) int rc; Entry *e; char *type; - struct berval value; - struct berval *vals[2]; + struct berval vals[2]; + struct berval nvals[2], *nvalsp; AttributeDescription *ad; const char *text; char *next; @@ -64,20 +66,18 @@ str2entry( char *s ) */ #ifdef NEW_LOGGING - LDAP_LOG(( "operation", LDAP_LEVEL_DETAIL1, - "str2entry: \"%s\"\n", s ? s : "NULL" )); + LDAP_LOG( OPERATION, DETAIL1, "str2entry: \"%s\"\n", s ? s : "NULL", 0, 0 ); #else Debug( LDAP_DEBUG_TRACE, "=> str2entry\n", s ? s : "NULL", 0, 0 ); #endif /* initialize reader/writer lock */ - e = (Entry *) ch_malloc( sizeof(Entry) ); + e = (Entry *) ch_calloc( 1, sizeof(Entry) ); if( e == NULL ) { #ifdef NEW_LOGGING - LDAP_LOG(( "operation", LDAP_LEVEL_ERR, - "str2entry: entry allocation failed.\n" )); + LDAP_LOG( OPERATION, ERR, "str2entry: entry allocation failed.\n", 0, 0, 0 ); #else Debug( LDAP_DEBUG_ANY, "<= str2entry NULL (entry allocation failed)\n", @@ -88,16 +88,10 @@ str2entry( char *s ) /* initialize entry */ e->e_id = NOID; - e->e_name.bv_val = NULL; - e->e_name.bv_len = 0; - e->e_nname.bv_val = NULL; - e->e_nname.bv_len = 0; - e->e_attrs = NULL; - e->e_private = NULL; /* dn + attributes */ - vals[0] = &value; - vals[1] = NULL; + vals[1].bv_len = 0; + vals[1].bv_val = NULL; next = s; while ( (s = ldif_getline( &next )) != NULL ) { @@ -105,10 +99,9 @@ str2entry( char *s ) break; } - if ( ldif_parse_line( s, &type, &value.bv_val, &value.bv_len ) != 0 ) { + if ( ldif_parse_line( s, &type, &vals[0].bv_val, &vals[0].bv_len ) != 0 ) { #ifdef NEW_LOGGING - LDAP_LOG(( "operation", LDAP_LEVEL_DETAIL1, - "str2entry: NULL (parse_line)\n" )); + LDAP_LOG( OPERATION, DETAIL1, "str2entry: NULL (parse_line)\n",0, 0, 0 ); #else Debug( LDAP_DEBUG_TRACE, "<= str2entry NULL (parse_line)\n", 0, 0, 0 ); @@ -117,44 +110,39 @@ str2entry( char *s ) } if ( strcasecmp( type, "dn" ) == 0 ) { - struct berval *pdn = NULL; - free( type ); if ( e->e_dn != NULL ) { #ifdef NEW_LOGGING - LDAP_LOG(( "operation", LDAP_LEVEL_DETAIL1, "str2entry: " + LDAP_LOG( OPERATION, DETAIL1, "str2entry: " "entry %ld has multiple DNs \"%s\" and \"%s\"\n", - (long) e->e_id, e->e_dn, - value.bv_val != NULL ? value.bv_val : "" )); + (long) e->e_id, e->e_dn, vals[0].bv_val ); #else Debug( LDAP_DEBUG_ANY, "str2entry: " "entry %ld has multiple DNs \"%s\" and \"%s\"\n", - (long) e->e_id, e->e_dn, - value.bv_val != NULL ? value.bv_val : "" ); + (long) e->e_id, e->e_dn, vals[0].bv_val ); #endif - if( value.bv_val != NULL ) free( value.bv_val ); + free( vals[0].bv_val ); entry_free( e ); return NULL; } - rc = dnPrettyNormal( NULL, &value, &e->e_name, &e->e_nname ); - free( value.bv_val ); + rc = dnPrettyNormal( NULL, &vals[0], &e->e_name, &e->e_nname, NULL ); if( rc != LDAP_SUCCESS ) { #ifdef NEW_LOGGING - LDAP_LOG(( "operation", LDAP_LEVEL_DETAIL1, "str2entry: " - "entry %ld has invalid DN \"%s\"\n", - (long) e->e_id, - pdn->bv_val ? pdn->bv_val : "" )); + LDAP_LOG( OPERATION, DETAIL1, + "str2entry: entry %ld has invalid DN \"%s\"\n", + (long) e->e_id, vals[0].bv_val, 0 ); #else Debug( LDAP_DEBUG_ANY, "str2entry: " "entry %ld has invalid DN \"%s\"\n", - (long) e->e_id, - pdn->bv_val ? pdn->bv_val : "", 0 ); + (long) e->e_id, vals[0].bv_val, 0 ); #endif entry_free( e ); + free( vals[0].bv_val ); return NULL; } + free( vals[0].bv_val ); continue; } @@ -163,8 +151,8 @@ str2entry( char *s ) if( rc != LDAP_SUCCESS ) { #ifdef NEW_LOGGING - LDAP_LOG(( "operation", LDAP_LEVEL_DETAIL1, - "str2entry: str2ad(%s): %s\n", type, text )); + LDAP_LOG( OPERATION, DETAIL1, + "str2entry: str2ad(%s): %s\n", type, text, 0 ); #else Debug( slapMode & SLAP_TOOL_MODE ? LDAP_DEBUG_ANY : LDAP_DEBUG_TRACE, @@ -172,7 +160,7 @@ str2entry( char *s ) #endif if( slapMode & SLAP_TOOL_MODE ) { entry_free( e ); - free( value.bv_val ); + free( vals[0].bv_val ); free( type ); return NULL; } @@ -180,22 +168,22 @@ str2entry( char *s ) rc = slap_str2undef_ad( type, &ad, &text ); if( rc != LDAP_SUCCESS ) { #ifdef NEW_LOGGING - LDAP_LOG(( "operation", LDAP_LEVEL_DETAIL1, - "str2entry: str2undef_ad(%s): %s\n", type, text )); + LDAP_LOG( OPERATION, DETAIL1, + "str2entry: str2undef_ad(%s): %s\n", type, text, 0 ); #else Debug( LDAP_DEBUG_ANY, "<= str2entry: str2undef_ad(%s): %s\n", type, text, 0 ); #endif entry_free( e ); - free( value.bv_val ); + free( vals[0].bv_val ); free( type ); return NULL; } } if( slapMode & SLAP_TOOL_MODE ) { - struct berval *pval = NULL; + struct berval pval; slap_syntax_validate_func *validate = ad->ad_type->sat_syntax->ssyn_validate; slap_syntax_transform_func *pretty = @@ -203,89 +191,121 @@ str2entry( char *s ) if( pretty ) { rc = pretty( ad->ad_type->sat_syntax, - &value, &pval ); + &vals[0], &pval, NULL ); } else if( validate ) { /* * validate value per syntax */ - rc = validate( ad->ad_type->sat_syntax, &value ); + rc = validate( ad->ad_type->sat_syntax, &vals[0] ); } else { #ifdef NEW_LOGGING - LDAP_LOG(( "operation", LDAP_LEVEL_INFO, + LDAP_LOG( OPERATION, INFO, "str2entry: no validator for syntax %s\n", - ad->ad_type->sat_syntax->ssyn_oid )); + ad->ad_type->sat_syntax->ssyn_oid, 0, 0 ); #else Debug( LDAP_DEBUG_ANY, "str2entry: no validator for syntax %s\n", ad->ad_type->sat_syntax->ssyn_oid, 0, 0 ); #endif entry_free( e ); - free( value.bv_val ); + free( vals[0].bv_val ); free( type ); return NULL; } if( rc != 0 ) { #ifdef NEW_LOGGING - LDAP_LOG(( "operation", LDAP_LEVEL_ERR, + LDAP_LOG( OPERATION, ERR, "str2entry: invalid value for syntax %s\n", - ad->ad_type->sat_syntax->ssyn_oid )); + ad->ad_type->sat_syntax->ssyn_oid, 0, 0 ); #else Debug( LDAP_DEBUG_ANY, "str2entry: invalid value for syntax %s\n", ad->ad_type->sat_syntax->ssyn_oid, 0, 0 ); #endif entry_free( e ); - free( value.bv_val ); + free( vals[0].bv_val ); free( type ); return NULL; } if( pretty ) { - free( value.bv_val ); - value = *pval; - free( pval ); + free( vals[0].bv_val ); + vals[0] = pval; } } - rc = attr_merge( e, ad, vals ); + nvalsp = NULL; + nvals[0].bv_val = NULL; + + if( ad->ad_type->sat_equality && + ad->ad_type->sat_equality->smr_normalize ) + { + rc = ad->ad_type->sat_equality->smr_normalize( + SLAP_MR_VALUE_OF_ATTRIBUTE_SYNTAX, + ad->ad_type->sat_syntax, + ad->ad_type->sat_equality, + &vals[0], &nvals[0], NULL ); + + if( rc ) { +#ifdef NEW_LOGGING + LDAP_LOG( OPERATION, DETAIL1, + "str2entry: NULL (smr_normalize %d)\n" , rc, 0, 0 ); +#else + Debug( LDAP_DEBUG_ANY, + "<= str2entry NULL (smr_normalize %d)\n", rc, 0, 0 ); +#endif + + entry_free( e ); + free( vals[0].bv_val ); + free( type ); + return NULL; + } + + nvals[1].bv_len = 0; + nvals[1].bv_val = NULL; + + nvalsp = &nvals[0]; + } + + rc = attr_merge( e, ad, vals, nvalsp ); if( rc != 0 ) { #ifdef NEW_LOGGING - LDAP_LOG(( "operation", LDAP_LEVEL_DETAIL1, - "str2entry: NULL (attr_merge)\n" )); + LDAP_LOG( OPERATION, DETAIL1, + "str2entry: NULL (attr_merge)\n" , 0, 0, 0 ); #else Debug( LDAP_DEBUG_ANY, "<= str2entry NULL (attr_merge)\n", 0, 0, 0 ); #endif entry_free( e ); - free( value.bv_val ); + free( vals[0].bv_val ); free( type ); return( NULL ); } free( type ); - free( value.bv_val ); + free( vals[0].bv_val ); + free( nvals[0].bv_val ); } /* check to make sure there was a dn: line */ if ( e->e_dn == NULL ) { #ifdef NEW_LOGGING - LDAP_LOG(( "operation", LDAP_LEVEL_INFO, - "str2entry: entry %ld has no dn.\n", - (long) e->e_id )); + LDAP_LOG( OPERATION, INFO, + "str2entry: entry %ld has no dn.\n", (long) e->e_id, 0, 0 ); #else Debug( LDAP_DEBUG_ANY, "str2entry: entry %ld has no dn\n", (long) e->e_id, 0, 0 ); #endif entry_free( e ); - return( NULL ); + return NULL; } #ifdef NEW_LOGGING - LDAP_LOG(( "operation", LDAP_LEVEL_DETAIL2, - "str2entry(%s) -> 0x%lx\n", e->e_dn, (unsigned long)e )); + LDAP_LOG( OPERATION, DETAIL2, + "str2entry(%s) -> 0x%lx\n", e->e_dn, (unsigned long)e, 0 ); #else Debug(LDAP_DEBUG_TRACE, "<= str2entry(%s) -> 0x%lx\n", e->e_dn, (unsigned long) e, 0 ); @@ -317,6 +337,8 @@ entry2str( int i; ber_len_t tmplen; + assert( e != NULL ); + /* * In string format, an entry looks like this: * dn: \n @@ -336,8 +358,8 @@ entry2str( /* put the attributes */ for ( a = e->e_attrs; a != NULL; a = a->a_next ) { /* put ":[:] " line for each value */ - for ( i = 0; a->a_vals[i] != NULL; i++ ) { - bv = a->a_vals[i]; + for ( i = 0; a->a_vals[i].bv_val != NULL; i++ ) { + bv = &a->a_vals[i]; tmplen = a->a_desc->ad_cname.bv_len; MAKE_SPACE( LDIF_SIZE_NEEDED( tmplen, bv->bv_len )); ldif_sput( (char **) &ecur, LDIF_PUT_VALUE, @@ -372,6 +394,11 @@ entry_free( Entry *e ) e->e_ndn = NULL; } + if ( e->e_bv.bv_val != NULL ) { + free( e->e_bv.bv_val ); + e->e_bv.bv_val = NULL; + } + /* free attributes */ attrs_free( e->e_attrs ); e->e_attrs = NULL; @@ -399,20 +426,25 @@ entry_cmp( Entry *e1, Entry *e2 ) } int -entry_dn_cmp( Entry *e1, Entry *e2 ) +entry_dn_cmp( const void *v_e1, const void *v_e2 ) { /* compare their normalized UPPERCASED dn's */ + const Entry *e1 = v_e1, *e2 = v_e2; + int rc = e1->e_nname.bv_len - e2->e_nname.bv_len; + if (rc) return rc; return( strcmp( e1->e_ndn, e2->e_ndn ) ); } int -entry_id_cmp( Entry *e1, Entry *e2 ) +entry_id_cmp( const void *v_e1, const void *v_e2 ) { + const Entry *e1 = v_e1, *e2 = v_e2; return( e1->e_id < e2->e_id ? -1 : (e1->e_id > e2->e_id ? 1 : 0) ); } -#ifdef SLAPD_BDB - +#define entry_lenlen(l) ((l) < 0x80) ? 1 : ((l) < 0x100) ? 2 : \ + ((l) < 0x10000) ? 3 : ((l) < 0x1000000) ? 4 : 5 +#if 0 /* This is like a ber_len */ static ber_len_t entry_lenlen(ber_len_t len) @@ -427,6 +459,7 @@ entry_lenlen(ber_len_t len) return 4; return 5; } +#endif static void entry_putlen(unsigned char **buf, ber_len_t len) @@ -464,6 +497,52 @@ entry_getlen(unsigned char **buf) return len; } +/* Add up the size of the entry for a flattened buffer */ +void entry_flatsize(Entry *e, ber_len_t *psiz, ber_len_t *plen, int norm) +{ + ber_len_t siz = sizeof(Entry); + ber_len_t len, dnlen, ndnlen; + int i; + Attribute *a; + + dnlen = e->e_name.bv_len; + len = dnlen + 1; /* trailing NUL byte */ + len += entry_lenlen(dnlen); + if (norm) { + ndnlen = e->e_nname.bv_len; + len += ndnlen + 1; + len += entry_lenlen(ndnlen); + } + for (a=e->e_attrs; a; a=a->a_next) { + /* For AttributeDesc, we only store the attr name */ + siz += sizeof(Attribute); + len += a->a_desc->ad_cname.bv_len+1; + len += entry_lenlen(a->a_desc->ad_cname.bv_len); + for (i=0; a->a_vals[i].bv_val; i++) { + siz += sizeof(struct berval); + len += a->a_vals[i].bv_len + 1; + len += entry_lenlen(a->a_vals[i].bv_len); + } + len += entry_lenlen(i); + siz += sizeof(struct berval); /* empty berval at end */ + if (norm && a->a_nvals != a->a_vals) { + for (i=0; a->a_nvals[i].bv_val; i++) { + siz += sizeof(struct berval); + len += a->a_nvals[i].bv_len + 1; + len += entry_lenlen(a->a_nvals[i].bv_len); + } + len += entry_lenlen(i); /* i nvals */ + siz += sizeof(struct berval); + } else { + len += entry_lenlen(0); /* 0 nvals */ + } + } + len += 1; /* NUL byte at end */ + len += entry_lenlen(siz); + *psiz = siz; + *plen = len; +} + /* Flatten an Entry into a buffer. The buffer is filled with just the * strings/bervals of all the entry components. Each field is preceded * by its length, encoded the way ber_put_len works. Every field is NUL @@ -480,63 +559,58 @@ int entry_encode(Entry *e, struct berval *bv) unsigned char *ptr; #ifdef NEW_LOGGING - LDAP_LOG(( "operation", LDAP_LEVEL_DETAIL1, - "entry_encode: id: 0x%08lx \"%s\"\n", - (long) e->e_id, e->e_dn )); + LDAP_LOG( OPERATION, DETAIL1, "entry_encode: id: 0x%08lx \"%s\"\n", + (long) e->e_id, e->e_dn, 0 ); #else Debug( LDAP_DEBUG_TRACE, "=> entry_encode(0x%08lx): %s\n", (long) e->e_id, e->e_dn, 0 ); #endif dnlen = e->e_name.bv_len; ndnlen = e->e_nname.bv_len; - len = dnlen + ndnlen + 2; /* two trailing NUL bytes */ - len += entry_lenlen(dnlen); - len += entry_lenlen(ndnlen); - for (a=e->e_attrs; a; a=a->a_next) { - /* For AttributeDesc, we only store the attr name */ - siz += sizeof(Attribute); - len += a->a_desc->ad_cname.bv_len+1; - len += entry_lenlen(a->a_desc->ad_cname.bv_len); - for (i=0; a->a_vals[i]; i++) { - siz += sizeof(struct berval *); - siz += sizeof(struct berval); - len += a->a_vals[i]->bv_len + 1; - len += entry_lenlen(a->a_vals[i]->bv_len); - } - len += entry_lenlen(i); - siz += sizeof(struct berval *); /* NULL pointer at end */ - } - len += 1; /* NUL byte at end */ - len += entry_lenlen(siz); + + entry_flatsize( e, &siz, &len, 1 ); + bv->bv_len = len; bv->bv_val = ch_malloc(len); ptr = (unsigned char *)bv->bv_val; entry_putlen(&ptr, siz); entry_putlen(&ptr, dnlen); - memcpy(ptr, e->e_dn, dnlen); + AC_MEMCPY(ptr, e->e_dn, dnlen); ptr += dnlen; *ptr++ = '\0'; entry_putlen(&ptr, ndnlen); - memcpy(ptr, e->e_ndn, ndnlen); + AC_MEMCPY(ptr, e->e_ndn, ndnlen); ptr += ndnlen; *ptr++ = '\0'; for (a=e->e_attrs; a; a=a->a_next) { entry_putlen(&ptr, a->a_desc->ad_cname.bv_len); - memcpy(ptr, a->a_desc->ad_cname.bv_val, + AC_MEMCPY(ptr, a->a_desc->ad_cname.bv_val, a->a_desc->ad_cname.bv_len); ptr += a->a_desc->ad_cname.bv_len; *ptr++ = '\0'; if (a->a_vals) { - for (i=0; a->a_vals[i]; i++); + for (i=0; a->a_vals[i].bv_val; i++); entry_putlen(&ptr, i); - for (i=0; a->a_vals[i]; i++) { - entry_putlen(&ptr, a->a_vals[i]->bv_len); - memcpy(ptr, a->a_vals[i]->bv_val, - a->a_vals[i]->bv_len); - ptr += a->a_vals[i]->bv_len; + for (i=0; a->a_vals[i].bv_val; i++) { + entry_putlen(&ptr, a->a_vals[i].bv_len); + AC_MEMCPY(ptr, a->a_vals[i].bv_val, + a->a_vals[i].bv_len); + ptr += a->a_vals[i].bv_len; *ptr++ = '\0'; } + if (a->a_nvals != a->a_vals) { + entry_putlen(&ptr, i); + for (i=0; a->a_nvals[i].bv_val; i++) { + entry_putlen(&ptr, a->a_nvals[i].bv_len); + AC_MEMCPY(ptr, a->a_nvals[i].bv_val, + a->a_nvals[i].bv_len); + ptr += a->a_nvals[i].bv_len; + *ptr++ = '\0'; + } + } else { + entry_putlen(&ptr, 0); + } } } *ptr = '\0'; @@ -545,7 +619,7 @@ int entry_encode(Entry *e, struct berval *bv) /* Retrieve an Entry that was stored using entry_encode above. * We malloc a single block with the size stored above for the Entry - * and all if its Attributes. We also must lookup the stored + * and all of its Attributes. We also must lookup the stored * attribute names to get AttributeDescriptions. To detect if the * attributes of an Entry are later modified, we note that e->e_attr * is always a constant offset from (e). @@ -556,18 +630,17 @@ int entry_encode(Entry *e, struct berval *bv) */ int entry_decode(struct berval *bv, Entry **e) { - int i, j; + int i, j, count; int rc; Attribute *a; Entry *x; const char *text; AttributeDescription *ad; unsigned char *ptr = (unsigned char *)bv->bv_val; - struct berval **bptr; - struct berval *vptr; + BerVarray bptr; i = entry_getlen(&ptr); - x = ch_malloc(i); + x = ch_calloc(1, i); i = entry_getlen(&ptr); x->e_name.bv_val = ptr; x->e_name.bv_len = i; @@ -577,44 +650,46 @@ int entry_decode(struct berval *bv, Entry **e) x->e_nname.bv_len = i; ptr += i+1; #ifdef NEW_LOGGING - LDAP_LOG(( "operation", LDAP_LEVEL_DETAIL2, - "entry_decode: \"%s\"\n", x->e_dn )); + LDAP_LOG( OPERATION, DETAIL2, "entry_decode: \"%s\"\n", x->e_dn, 0, 0 ); #else Debug( LDAP_DEBUG_TRACE, "entry_decode: \"%s\"\n", x->e_dn, 0, 0 ); #endif - x->e_private = bv->bv_val; + x->e_bv = *bv; /* A valid entry must have at least one attr, so this * pointer can never be NULL */ x->e_attrs = (Attribute *)(x+1); - bptr = (struct berval **)x->e_attrs; + bptr = (BerVarray)x->e_attrs; a = NULL; - while (i = entry_getlen(&ptr)) { + while ((i = entry_getlen(&ptr))) { + struct berval bv; + bv.bv_len = i; + bv.bv_val = ptr; if (a) { a->a_next = (Attribute *)bptr; } a = (Attribute *)bptr; ad = NULL; - rc = slap_str2ad( ptr, &ad, &text ); + rc = slap_bv2ad( &bv, &ad, &text ); if( rc != LDAP_SUCCESS ) { #ifdef NEW_LOGGING - LDAP_LOG(( "operation", LDAP_LEVEL_INFO, - "entry_decode: str2ad(%s): %s\n", ptr, text )); + LDAP_LOG( OPERATION, INFO, + "entry_decode: str2ad(%s): %s\n", ptr, text, 0 ); #else Debug( LDAP_DEBUG_TRACE, "<= entry_decode: str2ad(%s): %s\n", ptr, text, 0 ); #endif - rc = slap_str2undef_ad( ptr, &ad, &text ); + rc = slap_bv2undef_ad( &bv, &ad, &text ); if( rc != LDAP_SUCCESS ) { #ifdef NEW_LOGGING - LDAP_LOG(( "operation", LDAP_LEVEL_INFO, - "entry_decode: str2undef_ad(%s): %s\n", ptr, text)); + LDAP_LOG( OPERATION, INFO, + "entry_decode: str2undef_ad(%s): %s\n", ptr, text, 0 ); #else Debug( LDAP_DEBUG_ANY, "<= entry_decode: str2undef_ad(%s): %s\n", @@ -625,29 +700,45 @@ int entry_decode(struct berval *bv, Entry **e) } ptr += i + 1; a->a_desc = ad; - bptr = (struct berval **)(a+1); + bptr = (BerVarray)(a+1); a->a_vals = bptr; - j = entry_getlen(&ptr); - a->a_vals[j] = NULL; - vptr = (struct berval *)(bptr + j + 1); + a->a_flags = 0; + count = j = entry_getlen(&ptr); while (j) { i = entry_getlen(&ptr); - *bptr = vptr; - vptr->bv_len = i; - vptr->bv_val = (char *)ptr; + bptr->bv_len = i; + bptr->bv_val = (char *)ptr; ptr += i+1; bptr++; - vptr++; j--; } - bptr = (struct berval **)vptr; + bptr->bv_val = NULL; + bptr->bv_len = 0; + bptr++; + + j = entry_getlen(&ptr); + if (j) { + a->a_nvals = bptr; + while (j) { + i = entry_getlen(&ptr); + bptr->bv_len = i; + bptr->bv_val = (char *)ptr; + ptr += i+1; + bptr++; + j--; + } + bptr->bv_val = NULL; + bptr->bv_len = 0; + bptr++; + } else { + a->a_nvals = a->a_vals; + } } - if (a) - a->a_next = NULL; + + if (a) a->a_next = NULL; #ifdef NEW_LOGGING - LDAP_LOG(( "operation", LDAP_LEVEL_DETAIL1, - "entry_decode: %s\n", x->e_dn )); + LDAP_LOG( OPERATION, DETAIL1, "entry_decode: %s\n", x->e_dn, 0, 0 ); #else Debug(LDAP_DEBUG_TRACE, "<= entry_decode(%s)\n", x->e_dn, 0, 0 ); @@ -655,4 +746,3 @@ int entry_decode(struct berval *bv, Entry **e) *e = x; return 0; } -#endif