/* $OpenLDAP$ */
/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
*
- * Copyright 1998-2005 The OpenLDAP Foundation.
+ * Copyright 1998-2006 The OpenLDAP Foundation.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
#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 */
/*
{
int rc;
Entry *e;
- struct berval *nvalsp;
struct berval *type, *vals, *nvals;
char *freeval;
AttributeDescription *ad, *ad_prev;
int fv;
for (i=0; i<lines; i++) {
- k = i;
for ( j=i+1; j<lines; j++ ) {
if ( bvmatch( type+i, type+j )) {
/* out of order, move intervening attributes down */
- if ( j != k+1 ) {
- int l;
+ if ( j != i+1 ) {
bv = vals[j];
fv = freeval[j];
- for ( l=j; l>k; l-- ) {
- type[l] = type[l-1];
- vals[l] = vals[l-1];
- freeval[l] = freeval[l-1];
+ for ( k=j; k>i; k-- ) {
+ type[k] = type[k-1];
+ vals[k] = vals[k-1];
+ freeval[k] = freeval[k-1];
}
- type[l] = type[i];
- vals[l] = bv;
- freeval[l] = fv;
+ k++;
+ type[k] = type[i];
+ vals[k] = bv;
+ freeval[k] = fv;
}
- i = k = j;
+ i++;
}
}
}
goto fail;
}
- rc = slap_bv2undef_ad( type+i, &ad, &text );
+ rc = slap_bv2undef_ad( type+i, &ad, &text, 0 );
if( rc != LDAP_SUCCESS ) {
Debug( LDAP_DEBUG_ANY,
- "<= str2entry: str2undef_ad(%s): %s\n",
+ "<= str2entry: slap_str2undef_ad(%s): %s\n",
type[i].bv_val, text, 0 );
goto fail;
}
int j, k;
atail->a_next = (Attribute *) ch_malloc( sizeof(Attribute) );
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 &&
slap_syntax_transform_func *pretty =
ad->ad_type->sat_syntax->ssyn_pretty;
- if( pretty ) {
+ if ( pretty ) {
+#ifdef SLAP_ORDERED_PRETTYNORM
+ rc = ordered_value_pretty( ad,
+ &vals[i], &pval, NULL );
+#else /* ! SLAP_ORDERED_PRETTYNORM */
rc = pretty( ad->ad_type->sat_syntax,
&vals[i], &pval, NULL );
+#endif /* ! SLAP_ORDERED_PRETTYNORM */
- } else if( validate ) {
+ } else if ( validate ) {
/*
* validate value per syntax
*/
+#ifdef SLAP_ORDERED_PRETTYNORM
+ rc = ordered_value_validate( ad, &vals[i], LDAP_MOD_ADD );
+#else /* ! SLAP_ORDERED_PRETTYNORM */
rc = validate( ad->ad_type->sat_syntax, &vals[i] );
+#endif /* ! SLAP_ORDERED_PRETTYNORM */
} else {
Debug( LDAP_DEBUG_ANY,
}
}
- if( ad->ad_type->sat_equality &&
+ if ( ad->ad_type->sat_equality &&
ad->ad_type->sat_equality->smr_normalize )
{
+#ifdef SLAP_ORDERED_PRETTYNORM
+ rc = ordered_value_normalize(
+ SLAP_MR_VALUE_OF_ATTRIBUTE_SYNTAX,
+ ad,
+ ad->ad_type->sat_equality,
+ &vals[i], &nvals[i], NULL );
+#else /* ! SLAP_ORDERED_PRETTYNORM */
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[i], &nvals[i], NULL );
+#endif /* ! SLAP_ORDERED_PRETTYNORM */
- if( rc ) {
+ if ( rc ) {
Debug( LDAP_DEBUG_ANY,
"<= str2entry NULL (smr_normalize %d)\n", rc, 0, 0 );
goto fail;
while ( ecur + (n) > ebuf + emaxsize ) { \
ptrdiff_t offset; \
offset = (int) (ecur - ebuf); \
- ebuf = (unsigned char *) ch_realloc( (char *) ebuf, \
+ ebuf = ch_realloc( ebuf, \
emaxsize + GRABSIZE ); \
emaxsize += GRABSIZE; \
ecur = ebuf + offset; \
/* put "dn: <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 */
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 );
}
*ecur = '\0';
*len = ecur - ebuf;
- return( (char *) ebuf );
+ return( ebuf );
}
void
return( e1->e_id < e2->e_id ? -1 : (e1->e_id > e2->e_id ? 1 : 0) );
}
-#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)
-{
- if (len <= 0x7f)
- return 1;
- if (len <= 0xff)
- return 2;
- if (len <= 0xffff)
- return 3;
- if (len <= 0xffffff)
- return 4;
- return 5;
-}
-#endif
+#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)
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)
+/* 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 siz = sizeof(Entry);
ber_len_t len, dnlen, ndnlen;
- int i;
+ int i, nat = 0, nval = 0;
Attribute *a;
dnlen = e->e_name.bv_len;
}
for (a=e->e_attrs; a; a=a->a_next) {
/* For AttributeDesc, we only store the attr name */
- siz += sizeof(Attribute);
+ 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++) {
- siz += sizeof(struct berval);
+ nval++;
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 */
+ nval++; /* 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);
+ nval++;
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);
+ nval++;
} else {
len += entry_lenlen(0); /* 0 nvals */
}
}
- len += 1; /* NUL byte at end */
- len += entry_lenlen(siz);
- *psiz = siz;
+ 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
*/
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;
dnlen = e->e_name.bv_len;
ndnlen = e->e_nname.bv_len;
- entry_flatsize( e, &siz, &len, 1 );
+ 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);
AC_MEMCPY(ptr, e->e_dn, dnlen);
ptr += dnlen;
*ptr++ = '\0';
if (a->a_vals) {
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;
+ 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;
}
int entry_decode(struct berval *bv, Entry **e)
#endif
{
- int i, j, count;
+ int i, j, count, nattrs, nvals;
int rc;
Attribute *a;
Entry *x;
unsigned char *ptr = (unsigned char *)bv->bv_val;
BerVarray bptr;
- i = entry_getlen(&ptr);
- if (!i) {
+ nattrs = entry_getlen(&ptr);
+ if (!nattrs) {
+ Debug( LDAP_DEBUG_ANY,
+ "entry_decode: attribute count was zero\n", 0, 0, 0);
+ return LDAP_OTHER;
+ }
+ nvals = entry_getlen(&ptr);
+ if (!nvals) {
Debug( LDAP_DEBUG_ANY,
- "entry_decode: entry length was zero\n", 0, 0, 0);
+ "entry_decode: value count was zero\n", 0, 0, 0);
return LDAP_OTHER;
}
+ i = sizeof(Entry) + (nattrs * sizeof(Attribute)) +
+ (nvals * sizeof(struct berval));
#ifdef SLAP_ZONE_ALLOC
x = slap_zn_calloc(1, i + bv->bv_len, ctx);
AC_MEMCPY((char*)x + i, bv->bv_val, bv->bv_len);
bv->bv_val = (char*)x + i;
ptr = (unsigned char *)bv->bv_val;
- i = entry_getlen(&ptr);
+ /* pointer is reset, now advance past nattrs and nvals again */
+ entry_getlen(&ptr);
+ entry_getlen(&ptr);
#else
x = ch_calloc(1, i);
#endif
if( rc != LDAP_SUCCESS ) {
Debug( LDAP_DEBUG_TRACE,
"<= entry_decode: str2ad(%s): %s\n", ptr, text, 0 );
- rc = slap_bv2undef_ad( &bv, &ad, &text );
+ rc = slap_bv2undef_ad( &bv, &ad, &text, 0 );
if( rc != LDAP_SUCCESS ) {
Debug( LDAP_DEBUG_ANY,
- "<= entry_decode: str2undef_ad(%s): %s\n",
+ "<= entry_decode: slap_str2undef_ad(%s): %s\n",
ptr, text, 0 );
return rc;
}
} else {
a->a_nvals = a->a_vals;
}
+ nattrs--;
+ if ( !nattrs )
+ break;
}
if (a) a->a_next = NULL;
projects / openldap / blobdiff