X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=servers%2Fslapd%2Fentry.c;h=f074fb654964d1e699336fbd0a31e604f53e5f75;hb=298d439d596b198a3e96e4885dc80a9aba5e64be;hp=afc4272132759e7133ac52ad80e5446e4bb9dbb8;hpb=102cb932209b8fbdfd29ecb4f1b4101e7dd407c2;p=openldap diff --git a/servers/slapd/entry.c b/servers/slapd/entry.c index afc4272132..f074fb6549 100644 --- a/servers/slapd/entry.c +++ b/servers/slapd/entry.c @@ -1,8 +1,27 @@ /* entry.c - routines for dealing with entries */ /* $OpenLDAP$ */ -/* - * Copyright 1998-2000 The OpenLDAP Foundation, All Rights Reserved. - * COPYING RESTRICTIONS APPLY, see COPYRIGHT file +/* This work is part of OpenLDAP Software . + * + * Copyright 1998-2006 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) 1995 Regents of the University of Michigan. + * All rights reserved. + * + * Redistribution and use in source and binary forms are permitted + * provided that this notice is preserved and that due credit is given + * to the University of Michigan at Ann Arbor. The name of the University + * may not be used to endorse or promote products derived from this + * software without specific prior written permission. This software + * is provided ``as is'' without express or implied warranty. */ #include "portable.h" @@ -17,36 +36,83 @@ #include "slap.h" #include "ldif.h" -static unsigned char *ebuf; /* buf returned by entry2str */ -static unsigned char *ecur; /* pointer to end of currently used ebuf */ +static char *ebuf; /* buf returned by entry2str */ +static char *ecur; /* pointer to end of currently used ebuf */ 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 +}; + +/* + * these mutexes must be used when calling the entry2str() + * routine since it returns a pointer to static data. + */ +ldap_pvt_thread_mutex_t entry2str_mutex; + +static const struct berval dn_bv = BER_BVC("dn"); + +/* + * Entry free list + * + * Allocate in chunks, minimum of 1000 at a time. + */ +#define CHUNK_SIZE 1000 +typedef struct slap_list { + struct slap_list *next; +} slap_list; +static slap_list *entry_chunks; +static Entry *entry_list; +static ldap_pvt_thread_mutex_t entry_mutex; int entry_destroy(void) { - free( ebuf ); + slap_list *e; + if ( ebuf ) free( ebuf ); ebuf = NULL; ecur = NULL; emaxsize = 0; - return 0; + + for ( e=entry_chunks; e; e=entry_chunks ) { + entry_chunks = e->next; + free( e ); + } + + ldap_pvt_thread_mutex_destroy( &entry_mutex ); + ldap_pvt_thread_mutex_destroy( &entry2str_mutex ); + return attr_destroy(); } +int +entry_init(void) +{ + ldap_pvt_thread_mutex_init( &entry2str_mutex ); + ldap_pvt_thread_mutex_init( &entry_mutex ); + return attr_init(); +} Entry * str2entry( char *s ) +{ + return str2entry2( s, 1 ); +} + +Entry * +str2entry2( char *s, int checkvals ) { int rc; Entry *e; - char *type; - struct berval value; - struct berval *vals[2]; - AttributeDescription *ad; + struct berval *type, *vals, *nvals; + char *freeval; + AttributeDescription *ad, *ad_prev; const char *text; char *next; + int attr_cnt; + int i, lines; + Attribute ahead, *atail; /* * LDIF is used as the string format. @@ -63,262 +129,249 @@ str2entry( char *s ) * or newline. */ -#ifdef NEW_LOGGING - LDAP_LOG(( "operation", LDAP_LEVEL_DETAIL1, - "str2entry: \"%s\"\n", s ? s : "NULL" )); -#else - Debug( LDAP_DEBUG_TRACE, "=> str2entry\n", + Debug( LDAP_DEBUG_TRACE, "=> str2entry: \"%s\"\n", s ? s : "NULL", 0, 0 ); -#endif - /* initialize reader/writer lock */ - e = (Entry *) ch_malloc( sizeof(Entry) ); + e = entry_alloc(); if( e == NULL ) { -#ifdef NEW_LOGGING - LDAP_LOG(( "operation", LDAP_LEVEL_ERR, - "str2entry: entry allocation failed.\n" )); -#else Debug( LDAP_DEBUG_ANY, - "<= str2entry NULL (entry allocation failed)\n", - 0, 0, 0 ); -#endif + "<= str2entry NULL (entry allocation failed)\n", + 0, 0, 0 ); return( NULL ); } /* 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; - + atail = &ahead; + ahead.a_next = NULL; + ad = NULL; + ad_prev = NULL; + attr_cnt = 0; next = s; + + lines = ldif_countlines( s ); + type = ch_calloc( 1, (lines+1)*3*sizeof(struct berval)+lines ); + vals = type+lines+1; + nvals = vals+lines+1; + freeval = (char *)(nvals+lines+1); + i = -1; + + /* parse into individual values, record DN */ while ( (s = ldif_getline( &next )) != NULL ) { + int freev; if ( *s == '\n' || *s == '\0' ) { break; } + i++; - if ( ldif_parse_line( s, &type, &value.bv_val, &value.bv_len ) != 0 ) { -#ifdef NEW_LOGGING - LDAP_LOG(( "operation", LDAP_LEVEL_DETAIL1, - "str2entry: NULL (parse_line)\n" )); -#else + rc = ldif_parse_line2( s, type+i, vals+i, &freev ); + freeval[i] = freev; + if ( rc ) { Debug( LDAP_DEBUG_TRACE, - "<= str2entry NULL (parse_line)\n", 0, 0, 0 ); -#endif + "<= str2entry NULL (parse_line)\n", 0, 0, 0 ); continue; } - if ( strcasecmp( type, "dn" ) == 0 ) { - struct berval *pdn = NULL; - - free( type ); + if ( type[i].bv_len == dn_bv.bv_len && + strcasecmp( type[i].bv_val, dn_bv.bv_val ) == 0 ) { if ( e->e_dn != NULL ) { -#ifdef NEW_LOGGING - LDAP_LOG(( "operation", LDAP_LEVEL_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 : "" )); -#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 : "" ); -#endif - if( value.bv_val != NULL ) free( value.bv_val ); - entry_free( e ); - return NULL; + (long) e->e_id, e->e_dn, vals[i].bv_val ); + goto fail; } - rc = dnPretty( NULL, &value, &pdn ); - free( value.bv_val ); + rc = dnPrettyNormal( NULL, &vals[i], &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 : "" )); -#else Debug( LDAP_DEBUG_ANY, "str2entry: " "entry %ld has invalid DN \"%s\"\n", - (long) e->e_id, - pdn->bv_val ? pdn->bv_val : "", 0 ); -#endif - entry_free( e ); - return NULL; + (long) e->e_id, vals[i].bv_val, 0 ); + goto fail; } - - e->e_name.bv_val = ( pdn->bv_val != NULL ) - ? pdn->bv_val : ch_strdup( "" ); - e->e_name.bv_len = pdn->bv_len; - free( pdn ); + if ( freeval[i] ) free( vals[i].bv_val ); + vals[i].bv_val = NULL; + i--; continue; } + } + lines = i+1; - ad = NULL; - rc = slap_str2ad( type, &ad, &text ); + /* check to make sure there was a dn: line */ + if ( BER_BVISNULL( &e->e_name )) { + Debug( LDAP_DEBUG_ANY, "str2entry: entry %ld has no dn\n", + (long) e->e_id, 0, 0 ); + goto fail; + } - if( rc != LDAP_SUCCESS ) { -#ifdef NEW_LOGGING - LDAP_LOG(( "operation", LDAP_LEVEL_DETAIL1, - "str2entry: str2ad(%s): %s\n", type, text )); -#else - Debug( slapMode & SLAP_TOOL_MODE - ? LDAP_DEBUG_ANY : LDAP_DEBUG_TRACE, - "<= str2entry: str2ad(%s): %s\n", type, text, 0 ); -#endif - if( slapMode & SLAP_TOOL_MODE ) { - entry_free( e ); - free( value.bv_val ); - free( type ); - return NULL; + /* Make sure all attributes with multiple values are contiguous */ + if ( checkvals ) { + int j, k; + struct berval bv; + int fv; + + for (i=0; ii; k-- ) { + type[k] = type[k-1]; + vals[k] = vals[k-1]; + freeval[k] = freeval[k-1]; + } + k++; + type[k] = type[i]; + vals[k] = bv; + freeval[k] = fv; + } + i++; + } } + } + } + + for ( i=0; i<=lines; i++ ) { + ad_prev = ad; + if ( !ad || ( iad_cname ))) { + ad = NULL; + rc = slap_bv2ad( type+i, &ad, &text ); - 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 )); -#else - Debug( LDAP_DEBUG_ANY, - "<= str2entry: str2undef_ad(%s): %s\n", - type, text, 0 ); -#endif - entry_free( e ); - free( value.bv_val ); - free( type ); - return NULL; + Debug( slapMode & SLAP_TOOL_MODE + ? LDAP_DEBUG_ANY : LDAP_DEBUG_TRACE, + "<= str2entry: str2ad(%s): %s\n", type[i].bv_val, text, 0 ); + if( slapMode & SLAP_TOOL_MODE ) { + goto fail; + } + + rc = slap_bv2undef_ad( type+i, &ad, &text, 0 ); + if( rc != LDAP_SUCCESS ) { + Debug( LDAP_DEBUG_ANY, + "<= str2entry: slap_str2undef_ad(%s): %s\n", + type[i].bv_val, text, 0 ); + goto fail; + } + } + } + + if (( ad_prev && ad != ad_prev ) || ( i == lines )) { + int j, k; + atail->a_next = attr_alloc( NULL ); + atail = atail->a_next; + atail->a_flags = 0; + atail->a_desc = ad_prev; + atail->a_vals = ch_malloc( (attr_cnt + 1) * sizeof(struct berval)); + if( ad_prev->ad_type->sat_equality && + ad_prev->ad_type->sat_equality->smr_normalize ) + atail->a_nvals = ch_malloc( (attr_cnt + 1) * sizeof(struct berval)); + else + atail->a_nvals = NULL; + k = i - attr_cnt; + for ( j=0; ja_vals[j] = vals[k]; + else + ber_dupbv( atail->a_vals+j, &vals[k] ); + vals[k].bv_val = NULL; + if ( atail->a_nvals ) { + atail->a_nvals[j] = nvals[k]; + nvals[k].bv_val = NULL; + } + k++; + } + BER_BVZERO( &atail->a_vals[j] ); + if ( atail->a_nvals ) { + BER_BVZERO( &atail->a_nvals[j] ); + } else { + atail->a_nvals = atail->a_vals; } + attr_cnt = 0; + if ( i == lines ) break; } 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 = ad->ad_type->sat_syntax->ssyn_pretty; - if( pretty ) { - rc = pretty( ad->ad_type->sat_syntax, - &value, &pval ); + if ( pretty ) { + rc = ordered_value_pretty( ad, + &vals[i], &pval, NULL ); - } else if( validate ) { + } else if ( validate ) { /* * validate value per syntax */ - rc = validate( ad->ad_type->sat_syntax, &value ); + rc = ordered_value_validate( ad, &vals[i], LDAP_MOD_ADD ); } else { -#ifdef NEW_LOGGING - LDAP_LOG(( "operation", LDAP_LEVEL_INFO, - "str2entry: no validator for syntax %s\n", - ad->ad_type->sat_syntax->ssyn_oid )); -#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( type ); - return NULL; + "str2entry: attributeType %s #%d: " + "no validator for syntax %s\n", + ad->ad_cname.bv_val, attr_cnt, + ad->ad_type->sat_syntax->ssyn_oid ); + goto fail; } if( rc != 0 ) { -#ifdef NEW_LOGGING - LDAP_LOG(( "operation", LDAP_LEVEL_ERR, - "str2entry: invalid value for syntax %s\n", - ad->ad_type->sat_syntax->ssyn_oid )); -#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( type ); - return NULL; + "str2entry: invalid value " + "for attributeType %s #%d (syntax %s)\n", + ad->ad_cname.bv_val, attr_cnt, + ad->ad_type->sat_syntax->ssyn_oid ); + goto fail; } if( pretty ) { - free( value.bv_val ); - value = *pval; - free( pval ); + if ( freeval[i] ) free( vals[i].bv_val ); + vals[i] = pval; + freeval[i] = 1; } } - rc = attr_merge( e, ad, vals ); - if( rc != 0 ) { -#ifdef NEW_LOGGING - LDAP_LOG(( "operation", LDAP_LEVEL_DETAIL1, - "str2entry: NULL (attr_merge)\n" )); -#else - Debug( LDAP_DEBUG_ANY, - "<= str2entry NULL (attr_merge)\n", 0, 0, 0 ); -#endif - entry_free( e ); - free( value.bv_val ); - free( type ); - return( NULL ); - } - - free( type ); - free( value.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 )); -#else - Debug( LDAP_DEBUG_ANY, "str2entry: entry %ld has no dn\n", - (long) e->e_id, 0, 0 ); -#endif - entry_free( e ); - return( NULL ); - } - - /* generate normalized dn */ - { - struct berval *ndn = NULL; + if ( ad->ad_type->sat_equality && + ad->ad_type->sat_equality->smr_normalize ) + { + rc = ordered_value_normalize( + SLAP_MR_VALUE_OF_ATTRIBUTE_SYNTAX, + ad, + ad->ad_type->sat_equality, + &vals[i], &nvals[i], NULL ); - rc = dnNormalize( NULL, &e->e_name, &ndn ); - if( rc != LDAP_SUCCESS ) { -#ifdef NEW_LOGGING - LDAP_LOG(( "operation", LDAP_LEVEL_INFO, - "str2entry: entry %ld has invalid dn: %s\n", - (long) e->e_id, e->e_dn )); -#else - Debug( LDAP_DEBUG_ANY, - "str2entry: entry %ld has invalid dn: %s\n", - (long) e->e_id, e->e_dn, 0 ); -#endif - entry_free( e ); - return NULL; + if ( rc ) { + Debug( LDAP_DEBUG_ANY, + "<= str2entry NULL (smr_normalize %d)\n", rc, 0, 0 ); + goto fail; + } } - e->e_nname = *ndn; - free( ndn ); + attr_cnt++; } -#ifdef NEW_LOGGING - LDAP_LOG(( "operation", LDAP_LEVEL_DETAIL2, - "str2entry(%s) -> 0x%lx\n", e->e_dn, (unsigned long)e )); -#else + free( type ); + atail->a_next = NULL; + e->e_attrs = ahead.a_next; + Debug(LDAP_DEBUG_TRACE, "<= str2entry(%s) -> 0x%lx\n", e->e_dn, (unsigned long) e, 0 ); -#endif return( e ); + +fail: + for ( i=0; i ebuf + emaxsize ) { \ ptrdiff_t offset; \ offset = (int) (ecur - ebuf); \ - ebuf = (unsigned char *) ch_realloc( (char *) ebuf, \ - emaxsize + GRABSIZE ); \ + ebuf = ch_realloc( ebuf, \ + emaxsize + GRABSIZE ); \ emaxsize += GRABSIZE; \ ecur = ebuf + offset; \ } \ @@ -337,14 +390,16 @@ str2entry( char *s ) char * entry2str( - Entry *e, - int *len ) + Entry *e, + int *len ) { Attribute *a; struct berval *bv; int i; ber_len_t tmplen; + assert( e != NULL ); + /* * In string format, an entry looks like this: * dn: \n @@ -358,55 +413,106 @@ entry2str( /* put "dn: " */ tmplen = e->e_name.bv_len; MAKE_SPACE( LDIF_SIZE_NEEDED( 2, tmplen )); - ldif_sput( (char **) &ecur, LDIF_PUT_VALUE, "dn", e->e_dn, tmplen ); + ldif_sput( &ecur, LDIF_PUT_VALUE, "dn", e->e_dn, tmplen ); } /* 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, + ldif_sput( &ecur, LDIF_PUT_VALUE, a->a_desc->ad_cname.bv_val, - bv->bv_val, bv->bv_len ); + bv->bv_val, bv->bv_len ); } } MAKE_SPACE( 1 ); *ecur = '\0'; *len = ecur - ebuf; - return( (char *) ebuf ); + return( ebuf ); } void -entry_free( Entry *e ) +entry_clean( Entry *e ) { /* free an entry structure */ assert( e != NULL ); /* e_private must be freed by the caller */ assert( e->e_private == NULL ); - e->e_private = NULL; /* free DNs */ - if ( e->e_dn != NULL ) { - free( e->e_dn ); - e->e_dn = NULL; + if ( !BER_BVISNULL( &e->e_name ) ) { + free( e->e_name.bv_val ); + } + if ( !BER_BVISNULL( &e->e_nname ) ) { + free( e->e_nname.bv_val ); } - if ( e->e_ndn != NULL ) { - free( e->e_ndn ); - e->e_ndn = NULL; + + if ( !BER_BVISNULL( &e->e_bv ) ) { + free( e->e_bv.bv_val ); } /* free attributes */ attrs_free( e->e_attrs ); - e->e_attrs = NULL; - free( e ); + memset(e, 0, sizeof(Entry)); +} + +void +entry_free( Entry *e ) +{ + entry_clean( e ); + + ldap_pvt_thread_mutex_lock( &entry_mutex ); + e->e_private = entry_list; + entry_list = e; + ldap_pvt_thread_mutex_unlock( &entry_mutex ); +} + +int +entry_prealloc( int num ) +{ + Entry *e; + slap_list *s; + + if (!num) return 0; + + s = ch_calloc( 1, sizeof(slap_list) + num * sizeof(Entry)); + s->next = entry_chunks; + entry_chunks = s; + + e = (Entry *)(s+1); + for ( ;num>1; num--) { + e->e_private = e+1; + e++; + } + e->e_private = entry_list; + entry_list = (Entry *)(s+1); + + return 0; +} + +Entry * +entry_alloc( void ) +{ + Entry *e; + + ldap_pvt_thread_mutex_lock( &entry_mutex ); + if ( !entry_list ) + entry_prealloc( CHUNK_SIZE ); + e = entry_list; + entry_list = e->e_private; + e->e_private = NULL; + ldap_pvt_thread_mutex_unlock( &entry_mutex ); + + return e; } + /* * These routines are used only by Backend. * @@ -423,38 +529,28 @@ entry_free( Entry *e ) int entry_cmp( Entry *e1, Entry *e2 ) { - return( e1 < e2 ? -1 : (e1 > e2 ? 1 : 0) ); + return SLAP_PTRCMP( e1, 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 */ - return( strcmp( e1->e_ndn, e2->e_ndn ) ); + const Entry *e1 = v_e1, *e2 = v_e2; + + return ber_bvcmp( &e1->e_nname, &e2->e_nname ); } 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 - /* This is like a ber_len */ -static ber_len_t -entry_lenlen(ber_len_t len) -{ - if (len <= 0x7f) - return 1; - if (len <= 0xff) - return 2; - if (len <= 0xffff) - return 3; - if (len <= 0xffffff) - return 4; - return 5; -} +#define entry_lenlen(l) (((l) < 0x80) ? 1 : ((l) < 0x100) ? 2 : \ + ((l) < 0x10000) ? 3 : ((l) < 0x1000000) ? 4 : 5) static void entry_putlen(unsigned char **buf, ber_len_t len) @@ -492,6 +588,65 @@ entry_getlen(unsigned char **buf) return len; } +/* Count up the sizes of the components of an entry */ +void entry_partsize(Entry *e, ber_len_t *plen, + int *pnattrs, int *pnvals, int norm) +{ + ber_len_t len, dnlen, ndnlen; + int i, nat = 0, nval = 0; + 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 */ + nat++; + 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++) { + nval++; + len += a->a_vals[i].bv_len + 1; + len += entry_lenlen(a->a_vals[i].bv_len); + } + len += entry_lenlen(i); + nval++; /* empty berval at end */ + if (norm && a->a_nvals != a->a_vals) { + for (i=0; a->a_nvals[i].bv_val; i++) { + nval++; + len += a->a_nvals[i].bv_len + 1; + len += entry_lenlen(a->a_nvals[i].bv_len); + } + len += entry_lenlen(i); /* i nvals */ + nval++; + } else { + len += entry_lenlen(0); /* 0 nvals */ + } + } + len += entry_lenlen(nat); + len += entry_lenlen(nval); + *plen = len; + *pnattrs = nat; + *pnvals = nval; +} + +/* Add up the size of the entry for a flattened buffer */ +ber_len_t entry_flatsize(Entry *e, int norm) +{ + ber_len_t len; + int nattrs, nvals; + + entry_partsize(e, &len, &nattrs, &nvals, norm); + len += sizeof(Entry) + (nattrs * sizeof(Attribute)) + + (nvals * sizeof(struct berval)); + return 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 @@ -501,186 +656,282 @@ entry_getlen(unsigned char **buf) */ int entry_encode(Entry *e, struct berval *bv) { - ber_len_t siz = sizeof(Entry); ber_len_t len, dnlen, ndnlen; - int i; + int i, nattrs, nvals; Attribute *a; 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 )); -#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_partsize( e, &len, &nattrs, &nvals, 1 ); + bv->bv_len = len; bv->bv_val = ch_malloc(len); ptr = (unsigned char *)bv->bv_val; - entry_putlen(&ptr, siz); + entry_putlen(&ptr, nattrs); + entry_putlen(&ptr, nvals); 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++); - 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; - *ptr++ = '\0'; - } + for (i=0; a->a_vals[i].bv_val; i++); + entry_putlen(&ptr, i); + 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'; return 0; } /* 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 - * 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). + * First entry_header must be called to decode the size of the entry. + * Then a single block of memory must be malloc'd to accomodate the + * bervals and the bulk data. Next the bulk data is retrieved from + * the DB and parsed by entry_decode. * * Note: everything is stored in a single contiguous block, so * you can not free individual attributes or names from this * structure. Attempting to do so will likely corrupt memory. */ -int entry_decode(struct berval *bv, Entry **e) +int entry_header(EntryHeader *eh) +{ + unsigned char *ptr = (unsigned char *)eh->bv.bv_val; + + eh->nattrs = entry_getlen(&ptr); + if ( !eh->nattrs ) { + Debug( LDAP_DEBUG_ANY, + "entry_header: attribute count was zero\n", 0, 0, 0); + return LDAP_OTHER; + } + eh->nvals = entry_getlen(&ptr); + if ( !eh->nvals ) { + Debug( LDAP_DEBUG_ANY, + "entry_header: value count was zero\n", 0, 0, 0); + return LDAP_OTHER; + } + eh->data = (char *)ptr; + return LDAP_SUCCESS; +} + +#ifdef SLAP_ZONE_ALLOC +int entry_decode(EntryHeader *eh, Entry **e, void *ctx) +#else +int entry_decode(EntryHeader *eh, Entry **e) +#endif { - int i, j; + int i, j, count, nattrs, nvals; 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; - - i = entry_getlen(&ptr); - x = ch_malloc(i); + unsigned char *ptr = (unsigned char *)eh->bv.bv_val; + BerVarray bptr; + + nattrs = eh->nattrs; + nvals = eh->nvals; + x = entry_alloc(); + x->e_attrs = attrs_alloc( nattrs ); + ptr = (unsigned char *)eh->data; i = entry_getlen(&ptr); - x->e_name.bv_val = ptr; + x->e_name.bv_val = (char *) ptr; x->e_name.bv_len = i; ptr += i+1; i = entry_getlen(&ptr); - x->e_nname.bv_val = ptr; + x->e_nname.bv_val = (char *) ptr; 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 )); -#else Debug( LDAP_DEBUG_TRACE, - "entry_decode: \"%s\"\n", - x->e_dn, 0, 0 ); -#endif - x->e_private = bv->bv_val; + "entry_decode: \"%s\"\n", + x->e_dn, 0, 0 ); + x->e_bv = eh->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; - a = NULL; + a = x->e_attrs; + bptr = (BerVarray)eh->bv.bv_val; - while (i = entry_getlen(&ptr)) { - if (a) { - a->a_next = (Attribute *)bptr; - } - a = (Attribute *)bptr; + while ((i = entry_getlen(&ptr))) { + struct berval bv; + bv.bv_len = i; + bv.bv_val = (char *) ptr; 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 )); -#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, 0 ); if( rc != LDAP_SUCCESS ) { -#ifdef NEW_LOGGING - LDAP_LOG(( "operation", LDAP_LEVEL_INFO, - "entry_decode: str2undef_ad(%s): %s\n", ptr, text)); -#else Debug( LDAP_DEBUG_ANY, - "<= entry_decode: str2undef_ad(%s): %s\n", + "<= entry_decode: slap_str2undef_ad(%s): %s\n", ptr, text, 0 ); -#endif return rc; } } ptr += i + 1; a->a_desc = ad; - bptr = (struct berval **)(a+1); + a->a_flags = SLAP_ATTR_DONT_FREE_DATA | SLAP_ATTR_DONT_FREE_VALS; + count = j = entry_getlen(&ptr); a->a_vals = bptr; - j = entry_getlen(&ptr); - a->a_vals[j] = NULL; - vptr = (struct berval *)(bptr + j + 1); 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; + } + a = a->a_next; + nattrs--; + if ( !nattrs ) + break; } - if (a) - a->a_next = NULL; -#ifdef NEW_LOGGING - LDAP_LOG(( "operation", LDAP_LEVEL_DETAIL1, - "entry_decode: %s\n", x->e_dn )); -#else + Debug(LDAP_DEBUG_TRACE, "<= entry_decode(%s)\n", x->e_dn, 0, 0 ); -#endif *e = x; return 0; } + +Entry *entry_dup( Entry *e ) +{ + Entry *ret; + + ret = entry_alloc(); + + ret->e_id = e->e_id; + ber_dupbv( &ret->e_name, &e->e_name ); + ber_dupbv( &ret->e_nname, &e->e_nname ); + ret->e_attrs = attrs_dup( e->e_attrs ); + ret->e_ocflags = e->e_ocflags; + + return ret; +} + +#if 1 +/* Duplicates an entry using a single malloc. Saves CPU time, increases + * heap usage because a single large malloc is harder to satisfy than + * lots of small ones, and the freed space isn't as easily reusable. + * + * Probably not worth using this function. + */ +Entry *entry_dup_bv( Entry *e ) +{ + ber_len_t len; + int nattrs, nvals; + Entry *ret; + struct berval *bvl; + char *ptr; + Attribute *src, *dst; + + ret = entry_alloc(); + + entry_partsize(e, &len, &nattrs, &nvals, 1); + ret->e_id = e->e_id; + ret->e_attrs = attrs_alloc( nattrs ); + ret->e_ocflags = e->e_ocflags; + ret->e_bv.bv_len = len + nvals * sizeof(struct berval); + ret->e_bv.bv_val = ch_malloc( ret->e_bv.bv_len ); + + bvl = (struct berval *)ret->e_bv.bv_val; + ptr = (char *)(bvl + nvals); + + ret->e_name.bv_len = e->e_name.bv_len; + ret->e_name.bv_val = ptr; + AC_MEMCPY( ptr, e->e_name.bv_val, e->e_name.bv_len ); + ptr += e->e_name.bv_len; + *ptr++ = '\0'; + + ret->e_nname.bv_len = e->e_nname.bv_len; + ret->e_nname.bv_val = ptr; + AC_MEMCPY( ptr, e->e_nname.bv_val, e->e_nname.bv_len ); + ptr += e->e_name.bv_len; + *ptr++ = '\0'; + + dst = ret->e_attrs; + for (src = e->e_attrs; src; src=src->a_next,dst=dst->a_next ) { + int i; + dst->a_desc = src->a_desc; + dst->a_flags = SLAP_ATTR_DONT_FREE_DATA | SLAP_ATTR_DONT_FREE_VALS; + dst->a_vals = bvl; + for ( i=0; src->a_vals[i].bv_val; i++ ) { + bvl->bv_len = src->a_vals[i].bv_len; + bvl->bv_val = ptr; + AC_MEMCPY( ptr, src->a_vals[i].bv_val, bvl->bv_len ); + ptr += bvl->bv_len; + *ptr++ = '\0'; + bvl++; + } + BER_BVZERO(bvl); + bvl++; + if ( src->a_vals != src->a_nvals ) { + dst->a_nvals = bvl; + for ( i=0; src->a_nvals[i].bv_val; i++ ) { + bvl->bv_len = src->a_nvals[i].bv_len; + bvl->bv_val = ptr; + AC_MEMCPY( ptr, src->a_nvals[i].bv_val, bvl->bv_len ); + ptr += bvl->bv_len; + *ptr++ = '\0'; + bvl++; + } + BER_BVZERO(bvl); + bvl++; + } + } + return ret; +} #endif