lib: Updated du_buff not limit allowable PCI size

PCI can now occupy at most one block

2 files changed, 30 insertions, 21 deletions

diff --git a/src/lib/du_buff.c b/src/lib/du_buff.c
index cf523847..7e0f502e 100644
--- a/src/lib/du_buff.c
+++ b/src/lib/du_buff.c
@@ -24,16 +24,15 @@
 #include <malloc.h>
 #include <string.h>
 #include <errno.h>
-#include "ouroboros/du_buff.h"
+#include <ouroboros/du_buff.h>
+#include <ouroboros/list.h>
 
 #define OUROBOROS_PREFIX "du_buff"
 
-#ifndef DU_BUFF_BLOCKSIZE
-#define DU_BUFF_BLOCKSIZE (1 << 16)
-#endif
-
 #include "ouroboros/logs.h"
 
+#define DU_BLOCK_DATA_SIZE (DU_BUFF_BLOCK_SIZE - sizeof (struct buffer))
+
 struct buffer {
         uint8_t        * data;
         size_t           size;
@@ -79,9 +78,13 @@ struct buffer * buffer_create (size_t size, size_t headspace, size_t len)
 {
         struct buffer * head = NULL;
         size_t          remaining = size;
-        const size_t    page_size = DU_BUFF_BLOCKSIZE;
         size_t          ts = size - (headspace + len);
-        bool            head_block = true;
+
+        if (headspace > DU_BLOCK_DATA_SIZE || ts > DU_BLOCK_DATA_SIZE)
+        {
+                LOG_WARN("Illegal du_buff. Cannot fit PCI in DU_BUFF_BLOCK.");
+                return NULL;
+        }
 
         head = malloc(sizeof *head);
         if (head == NULL)
@@ -97,17 +100,15 @@ struct buffer * buffer_create (size_t size, size_t headspace, size_t len)
 
                 size_t sz;
 
-                if (size > DU_BUFF_BLOCKSIZE && head_block) {
-                        sz = headspace;
-                        head_block = false;
-                } else if (size > DU_BUFF_BLOCKSIZE
-                           && remaining - ts <= DU_BUFF_BLOCKSIZE
+                if (size > DU_BLOCK_DATA_SIZE
+                           && remaining - ts <=  DU_BLOCK_DATA_SIZE
                            && remaining != ts) {
                         sz = remaining - ts;
-                } else if (size > DU_BUFF_BLOCKSIZE && remaining == ts) {
+                } else if (size >  DU_BLOCK_DATA_SIZE && remaining == ts) {
                         sz = ts;
                 } else {
-                        sz = remaining < page_size ? remaining : page_size;
+                        sz = remaining <  DU_BLOCK_DATA_SIZE ?
+                                remaining :  DU_BLOCK_DATA_SIZE;
                 }
 
                 buf = malloc(sizeof *buf);
@@ -290,7 +291,7 @@ int du_buff_init(du_buff_t * dub,
         }
 
         if (start + len > dub->size) {
-                LOG_DBGF("Buffer too small for data %lu.", start);
+                LOG_DBGF("Buffer too small for data.");
                 return -EINVAL;
         }
 
diff --git a/src/lib/tests/du_buff_test.c b/src/lib/tests/du_buff_test.c
index 7bdf1459..2b7b5e55 100644
--- a/src/lib/tests/du_buff_test.c
+++ b/src/lib/tests/du_buff_test.c
@@ -20,10 +20,12 @@
  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#include <ouroboros/du_buff.h>
 #include "du_buff.c"
 
-#define TEST_BUFF_SIZE 16 * DU_BUFF_BLOCKSIZE
-#define MAX(a,b) a > b ? a : b
+#define TEST_BUFF_SIZE 16 * DU_BLOCK_DATA_SIZE
+#define MAX(a,b) (a > b ? a : b)
+#define MIN(a,b) (a < b ? a : b)
 
 int du_buff_test(int argc, char ** argv)
 {
@@ -35,17 +37,23 @@ int du_buff_test(int argc, char ** argv)
         for (i = 0; i < TEST_BUFF_SIZE; i++)
                 bits[i] = 170;
 
-        i_inc = MAX(1, DU_BUFF_BLOCKSIZE / 4);
-        j_inc = MAX(1, DU_BUFF_BLOCKSIZE / 8);
-        k_inc = MAX(1, DU_BUFF_BLOCKSIZE / 16);
+        i_inc = MAX(1, DU_BLOCK_DATA_SIZE / 4);
+        j_inc = MAX(1, DU_BLOCK_DATA_SIZE / 8);
+        k_inc = MAX(1, DU_BLOCK_DATA_SIZE / 16);
 
-        for (i = DU_BUFF_BLOCKSIZE / 4; i <= TEST_BUFF_SIZE; i += i_inc) {
+        for (i = DU_BUFF_BLOCK_SIZE / 4; i <= TEST_BUFF_SIZE; i += i_inc) {
                 for (j = 0; j < i; j += j_inc) {
                         for (k = 0; k < i - j; k += k_inc) {
                                 du_buff_t * dub = du_buff_create(i);
                                 if (dub == NULL)
                                         return -1;
 
+                                if (k > DU_BLOCK_DATA_SIZE)
+                                        continue;
+
+                                if (i - (j + k) > DU_BLOCK_DATA_SIZE)
+                                        continue;
+
                                 if (du_buff_init(dub, k, bits, j) < 0)
                                         return -1;