X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=servers%2Fslapd%2Fentry.c;h=1ce0a4fbc099dfd39421bab886890ccc4ff5d740;hb=e25f6ef0cdd1780577dffeaca8ba8b19b5697880;hp=0e0943513e559daa5f4223021007ff7cad1d48ff;hpb=0a25cddcf39d8acdb22acd3fa2ce1c5bb8b554a5;p=openldap diff --git a/servers/slapd/entry.c b/servers/slapd/entry.c index 0e0943513e..1ce0a4fbc0 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-2002 The OpenLDAP Foundation, All Rights Reserved. * COPYING RESTRICTIONS APPLY, see COPYRIGHT file */ @@ -24,11 +24,11 @@ static int emaxsize;/* max size of ebuf */ /* * Empty root entry */ -const Entry slap_entry_root = { NOID, "", "", NULL, NULL }; +const Entry slap_entry_root = { NOID, { 0, "" }, { 0, "" }, NULL, NULL }; int entry_destroy(void) { - free( ebuf ); + if ( ebuf ) free( ebuf ); ebuf = NULL; ecur = NULL; emaxsize = 0; @@ -42,8 +42,7 @@ str2entry( char *s ) int rc; Entry *e; char *type; - struct berval value; - struct berval *vals[2]; + struct berval vals[2]; AttributeDescription *ad; const char *text; char *next; @@ -65,7 +64,7 @@ str2entry( char *s ) #ifdef NEW_LOGGING LDAP_LOG(( "operation", LDAP_LEVEL_DETAIL1, - "str2entry: \"%s\"\n", s ? s : "NULL" )); + "str2entry: \"%s\"\n", s ? s : "NULL" )); #else Debug( LDAP_DEBUG_TRACE, "=> str2entry\n", s ? s : "NULL", 0, 0 ); @@ -77,7 +76,7 @@ str2entry( char *s ) if( e == NULL ) { #ifdef NEW_LOGGING LDAP_LOG(( "operation", LDAP_LEVEL_ERR, - "str2entry: entry allocation failed.\n" )); + "str2entry: entry allocation failed.\n" )); #else Debug( LDAP_DEBUG_ANY, "<= str2entry NULL (entry allocation failed)\n", @@ -88,14 +87,15 @@ str2entry( char *s ) /* initialize entry */ e->e_id = NOID; - e->e_dn = NULL; - e->e_ndn = NULL; + 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_val = NULL; next = s; while ( (s = ldif_getline( &next )) != NULL ) { @@ -103,7 +103,7 @@ 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" )); @@ -115,26 +115,44 @@ 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: " - "entry %ld has multiple dns \"%s\" and \"%s\" " - "(second ignored)\n", - (long) e->e_id, e->e_dn, value.bv_val != NULL ? value.bv_val : "" )); + "entry %ld has multiple DNs \"%s\" and \"%s\"\n", + (long) e->e_id, e->e_dn, + vals[0].bv_val != NULL ? vals[0].bv_val : "" )); #else Debug( LDAP_DEBUG_ANY, "str2entry: " - "entry %ld has multiple dns \"%s\" and \"%s\" " - "(second ignored)\n", + "entry %ld has multiple DNs \"%s\" and \"%s\"\n", (long) e->e_id, e->e_dn, - value.bv_val != NULL ? value.bv_val : "" ); + vals[0].bv_val != NULL ? vals[0].bv_val : "" ); #endif - if( value.bv_val != NULL ) free( value.bv_val ); - continue; + if( vals[0].bv_val != NULL ) free( vals[0].bv_val ); + entry_free( e ); + return NULL; } - e->e_dn = value.bv_val != NULL ? value.bv_val : ch_strdup( "" ); + rc = dnPrettyNormal( NULL, &vals[0], &e->e_name, &e->e_nname ); + free( vals[0].bv_val ); + 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; + } continue; } @@ -144,7 +162,7 @@ str2entry( char *s ) if( rc != LDAP_SUCCESS ) { #ifdef NEW_LOGGING LDAP_LOG(( "operation", LDAP_LEVEL_DETAIL1, - "str2entry: str2ad(%s): %s\n", type, text )); + "str2entry: str2ad(%s): %s\n", type, text )); #else Debug( slapMode & SLAP_TOOL_MODE ? LDAP_DEBUG_ANY : LDAP_DEBUG_TRACE, @@ -152,97 +170,108 @@ 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; } 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 )); + "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( vals[0].bv_val ); free( type ); return NULL; } } if( slapMode & SLAP_TOOL_MODE ) { + 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( !validate ) { + if( pretty ) { + rc = pretty( ad->ad_type->sat_syntax, + &vals[0], &pval ); + + } else if( validate ) { + /* + * validate value per syntax + */ + rc = validate( ad->ad_type->sat_syntax, &vals[0] ); + + } else { #ifdef NEW_LOGGING LDAP_LOG(( "operation", LDAP_LEVEL_INFO, - "str2entry: no validator for syntax %s\n", - ad->ad_type->sat_syntax->ssyn_oid )); + "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( vals[0].bv_val ); free( type ); return NULL; } - /* - * validate value per syntax - */ - rc = validate( ad->ad_type->sat_syntax, &value ); - 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 )); + "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( vals[0].bv_val ); free( type ); return NULL; } + + if( pretty ) { + free( vals[0].bv_val ); + vals[0] = pval; + } } rc = attr_merge( e, ad, vals ); - if( rc != 0 ) { #ifdef NEW_LOGGING LDAP_LOG(( "operation", LDAP_LEVEL_DETAIL1, - "str2entry: NULL (attr_merge)\n" )); + "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( vals[0].bv_val ); free( type ); return( NULL ); } free( type ); - free( value.bv_val ); + free( vals[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 )); + "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 ); @@ -251,13 +280,9 @@ str2entry( char *s ) return( NULL ); } - /* generate normalized dn */ - e->e_ndn = ch_strdup( e->e_dn ); - (void) dn_normalize( e->e_ndn ); - #ifdef NEW_LOGGING LDAP_LOG(( "operation", LDAP_LEVEL_DETAIL2, - "str2entry(%s) -> 0x%lx\n", e->e_dn, (unsigned long)e )); + "str2entry(%s) -> 0x%lx\n", e->e_dn, (unsigned long)e )); #else Debug(LDAP_DEBUG_TRACE, "<= str2entry(%s) -> 0x%lx\n", e->e_dn, (unsigned long) e, 0 ); @@ -286,7 +311,8 @@ entry2str( { Attribute *a; struct berval *bv; - int i, tmplen; + int i; + ber_len_t tmplen; /* * In string format, an entry looks like this: @@ -299,7 +325,7 @@ entry2str( /* put the dn */ if ( e->e_dn != NULL ) { /* put "dn: " */ - tmplen = strlen( e->e_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 ); } @@ -307,8 +333,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, @@ -373,6 +399,8 @@ int entry_dn_cmp( Entry *e1, Entry *e2 ) { /* compare their normalized UPPERCASED dn's */ + int rc = e1->e_nname.bv_len - e2->e_nname.bv_len; + if (rc) return rc; return( strcmp( e1->e_ndn, e2->e_ndn ) ); } @@ -384,26 +412,72 @@ entry_id_cmp( Entry *e1, Entry *e2 ) #ifdef SLAPD_BDB -/* Flatten an Entry into a buffer. The buffer contents become a direct - * copy of the entry, with all pointers converted to offsets from the - * beginning of the buffer. We do this by first walking through all - * the fields of the Entry, adding up their sizes. Then a single chunk - * of memory is malloc'd and the entry is copied. We differentiate between - * fixed size fields and variable-length content when tallying up the - * entry size, so that we can stick all of the variable-length stuff - * into the back half of the buffer. +/* 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; +} + +static void +entry_putlen(unsigned char **buf, ber_len_t len) +{ + ber_len_t lenlen = entry_lenlen(len); + + if (lenlen == 1) { + **buf = (unsigned char) len; + } else { + int i; + **buf = 0x80 | ((unsigned char) lenlen - 1); + for (i=lenlen-1; i>0; i--) { + (*buf)[i] = (unsigned char) len; + len >>= 8; + } + } + *buf += lenlen; +} + +static ber_len_t +entry_getlen(unsigned char **buf) +{ + ber_len_t len; + int i; + + len = *(*buf)++; + if (len <= 0x7f) + return len; + i = len & 0x7f; + len = 0; + for (;i > 0; i--) { + len <<= 8; + len |= *(*buf)++; + } + 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 + * terminated. The entire buffer size is precomputed so that a single + * malloc can be performed. The entry size is also recorded, + * to aid in entry_decode. */ -int entry_encode(Entry *e, struct berval **bv) +int entry_encode(Entry *e, struct berval *bv) { - int siz = sizeof(Entry); - int len, dnlen, ndnlen; - int i, j; - Entry *f; - Attribute *a, *b; - struct berval **bvl, *bz; - char *ptr, *base, *data; + ber_len_t siz = sizeof(Entry); + ber_len_t len, dnlen, ndnlen; + int i; + Attribute *a; + unsigned char *ptr; - *bv = ch_malloc(sizeof(struct berval)); #ifdef NEW_LOGGING LDAP_LOG(( "operation", LDAP_LEVEL_DETAIL1, "entry_encode: id: 0x%08lx \"%s\"\n", @@ -412,84 +486,67 @@ int entry_encode(Entry *e, struct berval **bv) Debug( LDAP_DEBUG_TRACE, "=> entry_encode(0x%08lx): %s\n", (long) e->e_id, e->e_dn, 0 ); #endif - dnlen = strlen(e->e_dn); - ndnlen = strlen(e->e_ndn); + 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; - for (i=0; a->a_vals[i]; i++) { - siz += sizeof(struct berval *); + 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 += a->a_vals[i].bv_len + 1; + len += entry_lenlen(a->a_vals[i].bv_len); } - siz += sizeof(struct berval *); /* NULL pointer at end */ + len += entry_lenlen(i); + siz += sizeof(struct berval); /* empty berval at end */ } - (*bv)->bv_len = siz + len; - (*bv)->bv_val = ch_malloc(siz+len); - base = (*bv)->bv_val; - ptr = base + siz; - f = (Entry *)base; - data = (char *)(f+1); - f->e_id = e->e_id; - f->e_dn = (char *)(ptr-base); - memcpy(ptr, e->e_dn, dnlen); + len += 1; /* NUL byte at end */ + len += entry_lenlen(siz); + bv->bv_len = len; + bv->bv_val = ch_malloc(len); + ptr = (unsigned char *)bv->bv_val; + entry_putlen(&ptr, siz); + entry_putlen(&ptr, dnlen); + AC_MEMCPY(ptr, e->e_dn, dnlen); ptr += dnlen; *ptr++ = '\0'; - f->e_ndn = (char *)(ptr-base); - memcpy(ptr, e->e_ndn, ndnlen); + entry_putlen(&ptr, ndnlen); + AC_MEMCPY(ptr, e->e_ndn, ndnlen); ptr += ndnlen; *ptr++ = '\0'; - f->e_attrs = e->e_attrs ? (Attribute *)sizeof(Entry) : NULL; - f->e_private = NULL; + for (a=e->e_attrs; a; a=a->a_next) { - b = (Attribute *)data; - data = (char *)(b+1); - b->a_desc = (AttributeDescription *)(ptr-base); - memcpy(ptr, a->a_desc->ad_cname.bv_val, + entry_putlen(&ptr, a->a_desc->ad_cname.bv_len); + 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) { - bvl = (struct berval **)data; - b->a_vals = (struct berval **)(data-base); - for (i=0; a->a_vals[i]; i++); - data = (char *)(bvl+i+1); - bz = (struct berval *)data; - for (j=0; jbv_len = a->a_vals[j]->bv_len; - if (a->a_vals[j]->bv_val) { - bz->bv_val = (char *)(ptr-base); - memcpy(ptr, a->a_vals[j]->bv_val, bz->bv_len); - } else { - bz->bv_val = NULL; - } - ptr += bz->bv_len; - *ptr++ = '\0'; - bvl[j] = (struct berval *)(data-base); - bz++; - data = (char *)bz; + 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); + memcpy(ptr, a->a_vals[i].bv_val, + a->a_vals[i].bv_len); + ptr += a->a_vals[i].bv_len; + *ptr++ = '\0'; } - bvl[j] = NULL; - } else { - b->a_vals = NULL; } - - if (a->a_next) - b->a_next = (Attribute *)(data-base); - else - b->a_next = NULL; } + *ptr = '\0'; return 0; } /* Retrieve an Entry that was stored using entry_encode above. - * All we have to do is add the buffer address to all of the - * stored offsets. 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). + * 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). * * Note: everything is stored in a single contiguous block, so * you can not free individual attributes or names from this @@ -497,71 +554,97 @@ int entry_encode(Entry *e, struct berval **bv) */ int entry_decode(struct berval *bv, Entry **e) { - int i; - long base; + int i, j; + int rc; Attribute *a; - Entry *x = (Entry *)bv->bv_val; - char *type; + Entry *x; const char *text; AttributeDescription *ad; - - base = (long)bv->bv_val; - x->e_dn += base; - x->e_ndn += base; + unsigned char *ptr = (unsigned char *)bv->bv_val; + BerVarray bptr; + + i = entry_getlen(&ptr); + x = ch_malloc(i); + i = entry_getlen(&ptr); + x->e_name.bv_val = ptr; + x->e_name.bv_len = i; + ptr += i+1; + i = entry_getlen(&ptr); + x->e_nname.bv_val = 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 )); + "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 = NULL; - if (x->e_attrs) - x->e_attrs = (Attribute *)((long)x->e_attrs+base); - for (a=x->e_attrs; a; a=a->a_next) { - if (a->a_next) - a->a_next = (Attribute *)((long)a->a_next+base); + x->e_private = bv->bv_val; + + /* A valid entry must have at least one attr, so this + * pointer can never be NULL + */ + x->e_attrs = (Attribute *)(x+1); + bptr = (BerVarray)x->e_attrs; + a = NULL; + + while (i = entry_getlen(&ptr)) { + struct berval bv = { i, ptr }; + if (a) { + a->a_next = (Attribute *)bptr; + } + a = (Attribute *)bptr; ad = NULL; - type = (char *)a->a_desc+base; - i = slap_str2ad( type, &ad, &text ); + rc = slap_bv2ad( &bv, &ad, &text ); - if( i != LDAP_SUCCESS ) { + if( rc != LDAP_SUCCESS ) { #ifdef NEW_LOGGING LDAP_LOG(( "operation", LDAP_LEVEL_INFO, - "entry_decode: str2ad(%s): %s\n", type, text )); + "entry_decode: str2ad(%s): %s\n", ptr, text )); #else Debug( LDAP_DEBUG_TRACE, - "<= entry_decode: str2ad(%s): %s\n", type, text, 0 ); + "<= entry_decode: str2ad(%s): %s\n", ptr, text, 0 ); #endif - i = slap_str2undef_ad( type, &ad, &text ); + rc = slap_bv2undef_ad( &bv, &ad, &text ); - if( i != LDAP_SUCCESS ) { + if( rc != LDAP_SUCCESS ) { #ifdef NEW_LOGGING LDAP_LOG(( "operation", LDAP_LEVEL_INFO, - "entry_decode: str2undef_ad(%s): %s\n", type, text)); + "entry_decode: str2undef_ad(%s): %s\n", ptr, text)); #else Debug( LDAP_DEBUG_ANY, "<= entry_decode: str2undef_ad(%s): %s\n", - type, text, 0 ); + ptr, text, 0 ); #endif - return i; + return rc; } } + ptr += i + 1; a->a_desc = ad; - if (a->a_vals) { - a->a_vals = (struct berval **)((long)a->a_vals+base); - for (i=0; a->a_vals[i]; i++) { - a->a_vals[i] = (struct berval *) - ((long)a->a_vals[i]+base); - if (a->a_vals[i]->bv_val) - a->a_vals[i]->bv_val += base; - } + bptr = (BerVarray)(a+1); + a->a_vals = bptr; + a->a_flags = 0; + j = entry_getlen(&ptr); + + 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++; } + if (a) + a->a_next = NULL; #ifdef NEW_LOGGING LDAP_LOG(( "operation", LDAP_LEVEL_DETAIL1, - "entry_decode: %s\n", x->e_dn )); + "entry_decode: %s\n", x->e_dn )); #else Debug(LDAP_DEBUG_TRACE, "<= entry_decode(%s)\n", x->e_dn, 0, 0 );