Make entry_encode/decode independent of slapd structure sizes

diff --git a/servers/slapd/entry.c b/servers/slapd/entry.c
index bd0274fb3964132199a8d0a33e3feabaaf060578..85fbba3ab8979b7bcd9516d07b51c28761d718bb 100644 (file)
--- a/servers/slapd/entry.c
+++ b/servers/slapd/entry.c
@@ -530,12 +530,12 @@ 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)
+/* 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;
@@ -548,32 +548,45 @@ void entry_flatsize(Entry *e, ber_len_t *psiz, ber_len_t *plen, int norm)
        }
        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(0); /* NUL byte at end */
+       len += entry_lenlen(nat) + 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
@@ -585,9 +598,8 @@ void entry_flatsize(Entry *e, ber_len_t *psiz, ber_len_t *plen, int norm)
  */
 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;
 
@@ -596,12 +608,13 @@ int entry_encode(Entry *e, struct berval *bv)
        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;
@@ -641,7 +654,6 @@ int entry_encode(Entry *e, struct berval *bv)
                        }
                }
        }
-       *ptr = '\0';
        return 0;
 }
 
@@ -662,7 +674,7 @@ int entry_decode(struct berval *bv, Entry **e, void *ctx)
 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;
@@ -671,18 +683,28 @@ int entry_decode(struct berval *bv, Entry **e)
        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
@@ -768,6 +790,9 @@ int entry_decode(struct berval *bv, Entry **e)
                } else {
                        a->a_nvals = a->a_vals;
                }
+               nattrs--;
+               if ( !nattrs )
+                       break;
        }
 
        if (a) a->a_next = NULL;

diff --git a/servers/slapd/proto-slap.h b/servers/slapd/proto-slap.h
index b9d28e54150fee24b301644eedcf3790b5eaed32..e2175c2279a54c518500709a063f3eb9423d0005 100644 (file)
--- a/servers/slapd/proto-slap.h
+++ b/servers/slapd/proto-slap.h
@@ -690,8 +690,10 @@ LDAP_SLAPD_F (Entry *) str2entry LDAP_P(( char     *s ));
 LDAP_SLAPD_F (Entry *) str2entry2 LDAP_P(( char        *s, int checkvals ));
 LDAP_SLAPD_F (char *) entry2str LDAP_P(( Entry *e, int *len ));
 
-LDAP_SLAPD_F (void) entry_flatsize LDAP_P((
-       Entry *e, ber_len_t *siz, ber_len_t *len, int norm ));
+LDAP_SLAPD_F (ber_len_t) entry_flatsize LDAP_P(( Entry *e, int norm ));
+LDAP_SLAPD_F (void) entry_partsize LDAP_P(( Entry *e, ber_len_t *len,
+       int *nattrs, int *nvals, int norm ));
+
 #ifdef SLAP_ZONE_ALLOC
 LDAP_SLAPD_F (int) entry_decode LDAP_P((
                                                struct berval *bv, Entry **e, void *ctx ));

diff --git a/servers/slapd/result.c b/servers/slapd/result.c
index aa90811c82b913348025cb73b082e5db5cf0682f..964a01c3afb6b5992f346fb411b568f712ddd1b8 100644 (file)
--- a/servers/slapd/result.c
+++ b/servers/slapd/result.c
@@ -791,11 +791,9 @@ slap_send_search_entry( Operation *op, SlapReply *rs )
                /* read back control or LDAP_CONNECTIONLESS */
            ber = op->o_res_ber;
        } else {
-               ber_len_t       siz, len;
                struct berval   bv;
 
-               entry_flatsize( rs->sr_entry, &siz, &len, 0 );
-               bv.bv_len = siz + len;
+               bv.bv_len = entry_flatsize( rs->sr_entry, 0 );
                bv.bv_val = op->o_tmpalloc(bv.bv_len, op->o_tmpmemctx );
 
                ber_init2( ber, &bv, LBER_USE_DER );
@@ -1517,7 +1515,6 @@ int slap_read_controls(
        BerElementBuffer berbuf;
        BerElement *ber = (BerElement *) &berbuf;
        LDAPControl c;
-       ber_len_t       siz, len;
        Operation myop;
 
        Debug( LDAP_DEBUG_ANY, "slap_read_controls: (%s) %s\n",
@@ -1527,8 +1524,7 @@ int slap_read_controls(
        rs->sr_attrs = ( oid == &slap_pre_read_bv ) ?
                op->o_preread_attrs : op->o_postread_attrs; 
 
-       entry_flatsize( rs->sr_entry, &siz, &len, 0 );
-       bv.bv_len = siz + len;
+       bv.bv_len = entry_flatsize( rs->sr_entry, 0 );
        bv.bv_val = op->o_tmpalloc(bv.bv_len, op->o_tmpmemctx );
 
        ber_init2( ber, &bv, LBER_USE_DER );