Gave aaip_0_2 a ring buffer rather than a shifted fifo

libisoburn/trunk/test/aaip_0_2.c

@@ -2,7 +2,7 @@
 /*
 
  Arbitrary Attribute Interchange Protocol , AAIP version 0.2
- Demonstration program for encoding and decoding EA and ACL.
+ Demonstration implementation of encoding and decoding EA and ACL.
 
  See test/aaip_0_2.h
      http://libburnia-project.org/wiki/AAIP
@@ -184,6 +184,12 @@ static int aaip_encode_pair(char *name, size_t attr_length, char *attr,
 /* Not less than 2 * 2048 */
 #define Aaip_buffer_sizE 4096
 
+/* Enough for one full component record and three empty ones which might get
+   added in case of unclean end of attribute list.
+*/
+#define Aaip_buffer_reservE (257 + 3 * 2)
+
+
 struct aaip_state {
 
   /* AA field status */
@@ -195,8 +201,9 @@ struct aaip_state {
 
   /* Buffer for component records */
   int recs_invalid;                          /* number of components to skip */
-  unsigned char recs[Aaip_buffer_sizE];
+  unsigned char recs[Aaip_buffer_sizE + Aaip_buffer_reservE];
   size_t recs_fill;
+  unsigned char *recs_start;
   int rec_head_missing;     /* number of bytes needed to complete rec header */
   int rec_missing;         /* number of bytes needed to complete current rec */
   int rec_ends;
@@ -207,6 +214,7 @@ struct aaip_state {
 
   /* Counter and meaning for completed components */
   unsigned int num_components;
+  size_t end_of_components; /* start index of eventual incomplete component */
   int first_is_name;
 
   /* Last return value of aaip_decode_pair() */
@@ -233,8 +241,9 @@ int aaip_init(struct aaip_state *aaip, char aa_name[2], int flag)
  aaip->aa_missing= 0;
 
  aaip->recs_invalid= 0;
- memset(aaip->recs, 0, Aaip_buffer_sizE);
+ memset(aaip->recs, 0, Aaip_buffer_sizE + Aaip_buffer_reservE);
  aaip->recs_fill= 0;
+ aaip->recs_start= aaip->recs;
  aaip->rec_head_missing= 2;
  aaip->rec_missing= 0;
  aaip->rec_ends= 0;
@@ -243,33 +252,217 @@ int aaip_init(struct aaip_state *aaip, char aa_name[2], int flag)
  aaip->ready_bytes= 0;
 
  aaip->num_components= 0;
+ aaip->end_of_components= 0;
  aaip->first_is_name= 1;
 
- aaip->pair_status= 1;
+ aaip->pair_status= 2;
  aaip->pairs_skipped= 0;
 
  return(1);
 }
 
+/*
+*/
+#define Aaip_with_ring_buffeR yes
+
+#ifdef Aaip_with_ring_buffeR
+
+/* Compute the one or two byte intervals in the ring buffer which form a
+   given byte interval in the virtual shift fifo.
+   @param idx           The byte start index in the virtual shift fifo.
+   @param todo          Number of bytes to cover
+   @param start_pt      Will return the start address of the first interval
+   @param at_start_pt   Will return the size of the first interval
+   @param at_recs       Will return the size of the second interval which
+                        always starts at aaip->recs
+   @param flag          Bitfield for control purposes
+   @return              1= next start_pt is *start_pt + *at_start_pt
+                        2= next start_pt is aaip->recs + *at_recs
+*/
+static int aaip_ring_adr(struct aaip_state *aaip, size_t idx, size_t todo,
+                         unsigned char **start_pt, size_t *at_start_pt,
+                         size_t *at_recs, int flag)
+{
+ size_t ahead;
+
+ ahead= Aaip_buffer_sizE + Aaip_buffer_reservE
+        - (aaip->recs_start - aaip->recs);
+ if(idx < ahead)
+   *start_pt= (aaip->recs_start + idx);
+ else
+   *start_pt= aaip->recs + (idx - ahead);
+ ahead= Aaip_buffer_sizE + Aaip_buffer_reservE - (*start_pt - aaip->recs);
+ if(todo >= ahead) {
+   *at_start_pt= ahead;
+   *at_recs= todo - ahead;
+   return(2);
+ }
+ *at_start_pt= todo;
+ *at_recs= 0;
+ return(1);
+}
+
+
+/* 
+   @param flag          Bitfield for control purposes
+                        bit0= count as ready_bytes
+*/
+static int aaip_push_to_recs(struct aaip_state *aaip, unsigned char *data,
+                             size_t todo, int flag)
+{
+ unsigned char *start_pt;
+ size_t at_start_pt, at_recs;
+
+ aaip_ring_adr(aaip, aaip->recs_fill, todo,
+               &start_pt, &at_start_pt, &at_recs, 0);
+ if(at_start_pt > 0)
+   memcpy(start_pt,  data, at_start_pt);
+ if(at_recs > 0)
+   memcpy(aaip->recs, data + at_start_pt, at_recs);
+ aaip->recs_fill+= todo;
+ if(flag &  1)
+   aaip->ready_bytes+= todo;
+ return(1);
+}
+
+
+static int aaip_read_from_recs(struct aaip_state *aaip, size_t idx,
+                               unsigned char *data, size_t num_data, int flag)
+{
+ unsigned char *start_pt;
+ size_t at_start_pt, at_recs;
+
+ aaip_ring_adr(aaip, idx, num_data,
+               &start_pt, &at_start_pt, &at_recs, 0);
+ if(at_start_pt > 0)
+   memcpy(data, start_pt, at_start_pt);
+ if(at_recs > 0)
+   memcpy(data + at_start_pt, aaip->recs, at_recs);
+ return(1);
+}
+
+
+static int aaip_set_buffer_byte(struct aaip_state *aaip, size_t idx,
+                                unsigned char data, int flag)
+{
+ unsigned char *start_pt;
+ size_t at_start_pt, at_recs;
+
+ aaip_ring_adr(aaip, idx, 1,
+               &start_pt, &at_start_pt, &at_recs, 0);
+ *start_pt= data;
+ return(1);
+}
+
+
+static int aaip_get_buffer_byte(struct aaip_state *aaip, size_t idx, int flag)
+{
+ unsigned char *start_pt;
+ size_t at_start_pt, at_recs;
+
+ aaip_ring_adr(aaip, idx, 1,
+               &start_pt, &at_start_pt, &at_recs, 0);
+ return((int) *start_pt);
+}
+
+
+static int aaip_shift_recs(struct aaip_state *aaip, size_t todo, int flag)
+{
+ int ret;
+ unsigned char *start_pt;
+ size_t at_start_pt, at_recs;
+
+ if(todo < aaip->recs_fill) {
+   ret= aaip_ring_adr(aaip, 0, todo, &start_pt, &at_start_pt, &at_recs, 0);
+   if(ret == 1)
+     aaip->recs_start= start_pt + todo;
+   else
+     aaip->recs_start= aaip->recs + at_recs;
+ } else {
+   aaip->recs_start= aaip->recs;
+ }
+ aaip->recs_fill-= todo;
+ if(aaip->end_of_components >= todo)
+   aaip->end_of_components-= todo;
+ else
+   aaip->end_of_components= 0;
+ return(1);
+}
+
+
+#else /* Aaip_with_ring_buffeR */
+
+
+/* 
+   @param flag          Bitfield for control purposes
+                        bit0= count as ready_bytes
+*/
+static int aaip_push_to_recs(struct aaip_state *aaip, unsigned char *data,
+                             size_t todo, int flag)
+{
+ memcpy(aaip->recs + aaip->recs_fill, data, todo);
+ aaip->recs_fill+= todo;
+ if(flag &  1)
+   aaip->ready_bytes+= todo;
+ return(1);
+}
+
+
+static int aaip_read_from_recs(struct aaip_state *aaip, size_t idx,
+                               unsigned char *data, size_t num_data, int flag)
+{
+ memcpy(data, aaip->recs + idx, num_data);
+ return(1);
+}
+
+
+static int aaip_set_buffer_byte(struct aaip_state *aaip, size_t idx,
+                                unsigned char data, int flag)
+{
+ aaip->recs[idx]= data;
+ return(1);
+}
+
+
+static int aaip_get_buffer_byte(struct aaip_state *aaip, size_t idx, int flag)
+{
+ return((int) aaip->recs[idx]);
+}
+
+
+static int aaip_shift_recs(struct aaip_state *aaip, size_t todo, int flag)
+{
+ if(todo < aaip->recs_fill)
+   memmove(aaip->recs, aaip->recs + todo, aaip->recs_fill - todo);
+ aaip->recs_fill-= todo;
+
+ if(aaip->end_of_components >= todo)
+   aaip->end_of_components-= todo;
+ else
+   aaip->end_of_components= 0;
+ return(1);
+}
+
+
+#endif /* ! Aaip_with_ring_buffeR */
+ 
 
 static int aaip_consume_rec_head(struct aaip_state *aaip,
                               unsigned char **data, size_t *num_data, int flag)
 {
- size_t todo, i;
+ size_t todo;
 
  todo= *num_data;
  if(todo > aaip->aa_missing)
    todo= aaip->aa_missing;
  if(todo >= aaip->rec_head_missing)
    todo= aaip->rec_head_missing;
- if(!aaip->recs_invalid) {
+ if(!aaip->recs_invalid)
-   memcpy(aaip->recs + aaip->recs_fill, *data + i, todo);
+   aaip_push_to_recs(aaip, *data, todo, 0);
-   aaip->recs_fill+= todo;
- }
  aaip->rec_head_missing-= todo;
  if(aaip->rec_head_missing == 0) {
-   aaip->rec_missing= aaip->recs[aaip->recs_fill - 1]; 
+   aaip->rec_missing= aaip_get_buffer_byte(aaip, aaip->recs_fill - 1, 0); 
-   aaip->rec_ends= !(aaip->recs[aaip->recs_fill - 2] & 1);
+   aaip->rec_ends= !(aaip_get_buffer_byte(aaip, aaip->recs_fill - 2, 0) & 1);
  }
  aaip->aa_missing-= todo;
  (*num_data)-= todo;
@@ -281,18 +474,15 @@ static int aaip_consume_rec_head(struct aaip_state *aaip,
 static int aaip_consume_rec_data(struct aaip_state *aaip,
                               unsigned char **data, size_t *num_data, int flag)
 {
- size_t todo, i;
+ size_t todo;
  
  todo= *num_data;
  if(todo > aaip->aa_missing)
    todo= aaip->aa_missing;
  if(todo > aaip->rec_missing)
    todo= aaip->rec_missing;
- if(!aaip->recs_invalid) {
+ if(!aaip->recs_invalid)
-   memcpy(aaip->recs + aaip->recs_fill, *data + i, todo);
+   aaip_push_to_recs(aaip, *data, todo, 1);
-   aaip->recs_fill+= todo;
-   aaip->ready_bytes+= todo;
- }
  aaip->rec_missing-= todo;
  aaip->aa_missing-= todo;
  (*num_data)-= todo;
@@ -303,8 +493,10 @@ static int aaip_consume_rec_data(struct aaip_state *aaip,
        aaip->recs_invalid--;
    } else {
      aaip->num_recs++;
-     if(aaip->rec_ends)
+     if(aaip->rec_ends) {
        aaip->num_components++;
+       aaip->end_of_components= aaip->recs_fill;
+     }
    }
    aaip->rec_head_missing= 2;
  }
@@ -315,21 +507,21 @@ static int aaip_consume_rec_data(struct aaip_state *aaip,
 static int aaip_consume_aa_head(struct aaip_state *aaip,
                               unsigned char **data, size_t *num_data, int flag)
 {
- size_t todo, i;
+ size_t todo;
+ unsigned char aa_head[5];
 
  todo= *num_data;
  if(todo >= aaip->aa_head_missing)
    todo= aaip->aa_head_missing;
- for(i= 0; i < todo; i++)
+ aaip_push_to_recs(aaip, *data, todo, 0);
-   aaip->recs[aaip->recs_fill++]= (*data)[i];
  aaip->aa_head_missing-= todo;
  if(aaip->aa_head_missing == 0) {
-   if(aaip->recs[aaip->recs_fill - 5] != aaip->aa_name[0] ||
+   aaip_read_from_recs(aaip, aaip->recs_fill - 5, aa_head, 5, 0);
-      aaip->recs[aaip->recs_fill - 4] != aaip->aa_name[1] ||
+   if(aa_head[0] != aaip->aa_name[0] || aa_head[1] != aaip->aa_name[1] ||
-      aaip->recs[aaip->recs_fill - 2] != 1)
+      aa_head[3] != 1)
      return(-1);
-   aaip->aa_missing= aaip->recs[aaip->recs_fill - 3];
+   aaip->aa_missing= aa_head[2];
-   aaip->aa_ends= !(aaip->recs[aaip->recs_fill - 1] & 1);
+   aaip->aa_ends= !(aa_head[4] & 1);
    aaip->recs_fill-= 5; /* AA heads do not get delivered */
    if(aaip->aa_missing >= 5)
      aaip->aa_missing-= 5;
@@ -345,6 +537,9 @@ static int aaip_consume_aa_head(struct aaip_state *aaip,
 static int aaip_consume_aa_data(struct aaip_state *aaip,
                               unsigned char **data, size_t *num_data, int flag)
 {
+ size_t i;
+ static unsigned char zero_char[2]= {0, 0};
+
  while(*num_data > 0 && aaip->aa_missing > 0) {
    if(aaip->rec_head_missing > 0) {
      aaip_consume_rec_head(aaip, data, num_data, 0);
@@ -355,9 +550,42 @@ static int aaip_consume_aa_data(struct aaip_state *aaip,
  }
  if(aaip->aa_missing <= 0) {
    if(aaip->aa_ends) {
-
+     /* Check for incomplete pair and eventually make emergency closure */
-     /* >>> Check for incomplete component or pair, discard it */;
+     if(aaip->rec_head_missing != 2) {         /* incomplete record detected */
-
+       if(aaip->rec_head_missing) {
+         /* fake 0 length record */
+         aaip_set_buffer_byte(aaip, aaip->recs_fill - 1, (unsigned char) 0, 0);
+         aaip_push_to_recs(aaip, zero_char, 1, 0);
+       } else {
+         /* fill in missing btes */
+         for(i= 0; i < aaip->rec_missing; i++)
+           aaip_push_to_recs(aaip, zero_char, 1, 1);
+       }
+       aaip->rec_head_missing= 2;
+       aaip->rec_missing= 0;
+       aaip->num_recs++;
+       if(aaip->rec_ends) {
+         aaip->num_components++;
+         aaip->end_of_components= aaip->recs_fill;
+       }
+     }
+     if(aaip->end_of_components != aaip->recs_fill &&
+        aaip->end_of_components != 0) {
+                                            /* incomplete component detected */
+       /* add empty end record */
+       aaip_push_to_recs(aaip, zero_char, 2, 0);
+       aaip->num_recs++;
+       aaip->num_components++;
+       aaip->end_of_components= aaip->recs_fill;
+     }
+     if(!(aaip->first_is_name ^ (aaip->num_components % 2))) {
+                                               /* value component is missing */
+       /* add dummy component */
+       aaip_push_to_recs(aaip, zero_char, 2, 0);
+       aaip->num_recs++;
+       aaip->num_components++;
+       aaip->end_of_components= aaip->recs_fill;
+     }
      aaip->aa_ends= 2;
    } else
      aaip->aa_head_missing= 5;
@@ -397,7 +625,7 @@ int aaip_submit_data(struct aaip_state *aaip,
  if(aaip->recs_fill + num_data > Aaip_buffer_sizE)
    return(0);
  
- while(aaip->aa_missing == 0 && num_data > 0) {
+ while(num_data > 0) {
    if(aaip->aa_head_missing > 0) {
      ret= aaip_consume_aa_head(aaip, &data, &num_data, 0);
      if(ret < 0) {
@@ -408,6 +636,8 @@ int aaip_submit_data(struct aaip_state *aaip,
        goto ex;
    }
    aaip_consume_aa_data(aaip, &data, &num_data, 0);
+   if(aaip->aa_missing)
+ break;
  }
 ex:;
  *ready_bytes= aaip->ready_bytes;
@@ -445,7 +675,7 @@ int aaip_fetch_data(struct aaip_state *aaip,
                     char *result, size_t result_size, size_t *num_result,
                     int flag)
 {
- int ret= -1, complete= 0;
+ int ret= -1, complete= 0, payload;
  unsigned int i, num_bytes= 0, h;
 
  if(aaip->num_recs == 0)
@@ -454,24 +684,24 @@ int aaip_fetch_data(struct aaip_state *aaip,
  /* Copy data until end of buffer or end of component */
  h= 0;
  for(i= 0; i < aaip->num_recs && !complete; i++) {
+   payload= aaip_get_buffer_byte(aaip, h + 1, 0);
    if(!(flag & 1)) {
-     if(num_bytes + aaip->recs[h + 1] > result_size)
+     if(num_bytes + payload > result_size)
        return(-2);
-     memcpy(result + num_bytes, aaip->recs + h + 2, aaip->recs[h + 1]);
+     aaip_read_from_recs(aaip, h + 2, (unsigned char *) (result + num_bytes),
-     *num_result= num_bytes + aaip->recs[h + 1];
+                         payload, 0);
+     *num_result= num_bytes + payload;
    }
-   num_bytes+= aaip->recs[h + 1];
+   num_bytes+= payload;
-   if(!(aaip->recs[h] & 1))
+   if(!(aaip_get_buffer_byte(aaip, h, 0) & 1))
      complete= 1;
-   h+= aaip->recs[h + 1] + 2;
+   h+= payload + 2;
  }
- aaip->num_recs-= i;
  aaip->ready_bytes-= num_bytes;
+ aaip->num_recs-= i;
 
  /* Shift buffer */
- if(h < aaip->recs_fill)
+ aaip_shift_recs(aaip, h, 0);
-   memmove(aaip->recs, aaip->recs + h, aaip->recs_fill - h);
- aaip->recs_fill-= h;
 
  /* Compute reply */
  ret= 2 * !aaip->first_is_name;
@@ -500,12 +730,12 @@ int aaip_skip_component(struct aaip_state *aaip, int flag)
 {
  int to_skip= 1;
 
- if(aaip->recs_invalid) {
-   aaip->recs_invalid+= 1 + (flag & 1);
-   return(1);
- }
  if(aaip->first_is_name && !(flag & 1))
    to_skip= 2;
+ if(aaip->recs_invalid) {
+   aaip->recs_invalid+= to_skip;
+   return(1);
+ }
 
  if(aaip->num_components) {
    /* null-fetch */

libisoburn/trunk/test/aaip_0_2.h

@@ -168,6 +168,7 @@ int aaip_skip_component(struct aaip_state *aaip, int flag);
             3 name and value are valid, pairs pending, fetch with num_data == 0
             4 name and value are valid, no more data expected
             5 name and value are not valid, no more data expected
+
 */
 int aaip_decode_pair(struct aaip_state *aaip,
                      unsigned char *data, size_t num_data, size_t *consumed,

libisoburn/trunk/test/aaip_0_2_test.c

@@ -26,6 +26,8 @@
 
 #include "aaip_0_2.h"
 
+#define Aaip_test_name_sizE 1024
+#define Aaip_test_value_sizE 1024
 
 int main(int argc, char **argv)
 {
@@ -37,11 +39,9 @@ int main(int argc, char **argv)
 
  struct aaip_state *aaip;
  size_t consumed= 0;
- char name[1025];
+ char name[Aaip_test_name_sizE + 1];
- size_t name_size= 4;
  size_t name_fill;
- char value[1025];
+ char value[Aaip_test_value_sizE + 1];
- size_t value_size= 1024;
  size_t value_fill;
  size_t todo;
  int submit_data, is_done;
@@ -126,8 +126,8 @@ int main(int argc, char **argv)
    } else
      todo= 0;
    ret= aaip_decode_pair(aaip, rpt, todo, &consumed,
-                         name, name_size, &name_fill,
+                         name, Aaip_test_name_sizE, &name_fill,
-                         value, value_size, &value_fill, 0);
+                         value, Aaip_test_value_sizE, &value_fill, 0);
    skipped= aaip_get_pairs_skipped(aaip, 0);
    if(skipped > was_skipped) {
      printf("- skipped %d pair%s -\n\n", skipped - was_skipped,