safe structures embedded systems

I have a packet from a server which is parsed in an embedded system. I need to parse it in a very efficient way, avoiding memory issues, like overlapping, corrupting my memory and others variables.

The packet has this structure "String A:String B:String C".

As example, here the packet received is 开发者_如何学编程compounded of three parts separated using a separator ":", all these parts must be accesibles from an structure.

Which is the most efficient and safe way to do this.

A.- Creating an structure with attributes (partA, PartB PartC) sized with a criteria based on avoid exceed this sized from the source of the packet, and attaching also an index with the length of each part in a way to avoid extracting garbage, this part length indicator could be less or equal to 300 (ie: part B).

typedef struct parsedPacket_struct {
  char partA[2];int len_partA;
  char partB[300];int len_partB;
  char partC[2];int len_partC;
}parsedPacket;

The problem here is that I am wasting memory, because each structure should copy the packet content to each the structure, is there a way to only save the base address of each part and still using the len_partX.

How about replacing the (:) with a 0, and add a null to the end - then you have three char * to pass around. You will need to deal with 0 length strings, but that might solve it

To avoid corrupting memory and other variables, you generally declare large data buffers as statics and place them at file scope, then allocate a separate RAM segment for them. Having them sitting on the stack is a bad idea in any embedded system.

You need to consider whether there is an alignment requirement for the CPU and whether the code should be portable or not. The compiler is free to add any number of padding bytes anywhere in that struct, meaning you may not be able to do this:

parsedPacket pp;

memcpy(&pp, raw_data, sizeof(parsedPacket )) ;

For this reason, structs are generally a bad choise for storing data packages. The safest solution is this:

/* packet.h */

typedef struct parsedPacket_struct {
  uint8_t* partA;
  uint8_t* partB;
  uint8_t* partC;

  uint16_t len_partA;
  uint16_t len_partB;
  uint16_t len_partC;

}parsedPacket;


#define MAX_PART_A    2
#define MAX_PART_B  300
#define MAX_PART_C    2


void packet_receive (parsedPacket* packet);



/* packet.c */

static uint8 partA[MAX_PART_A];
static uint8 partB[MAX_PART_B];
static uint8 partC[MAX_PART_C];

void packet_receive (parsedPacket* packet)
{
  /* receive data from server */
  ...

  packet->len_partA = ...;
  packet->len_partB = ...;
  packet->len_partC = ...;

  packet->partA = partA;
  packet->partB = partB;
  packet->partC = partC;

  memcpy(partA, A_from_server, packet->len_partA);
  memcpy(partB, B_from_server, packet->len_partB);
  memcpy(partC, C_from_server, packet->len_partC);
}

This can be extended to contain several static buffers if needed, ie a static array of arrays for each buffer. As you are dealing with large amounts of data in an embedded system, you can never allow the program to stack the buffers at a whim. The maximum amount of copies of a received packet must be determined during program design.

I'm not sure why you think your approach is wasting memory, but here's what I would do if I were feeling especially hacky:

typedef struct {
  char *a, *b, *c;
  char data[1]; // or 0 if your compiler lets you, or nothing in C99
} parsedPacket;

This is called a flexible array member. Basically, when you allocate memory for your struct, you do this:

parsedPacket *p = malloc(offsetof(parsedPacket, data[N]));

N above becomes the amount of data your array needs, i.e. how long the string you read is. This allocates the struct so that the data member has enough size for your entire string of data. Then, copy the string you recieve into this member, replace ':' characters with '\0', and set a to the first string (i.e. p->a = p->data), b to the second (p->b = p->data + strlen(p->a) + 1) and c to the third. Of course, you can make this process easier by doing it all at once:

size_t current = 0;
p->a = p->data;
p->b = p->c = NULL;
while(1)
  {
    int i = getc();
    if(i == '\n' || i == EOF) break; // or whatever end conditions you expect
    if(i == ':')
      {
        p->data[current] = '\0';
        ++current;
        if(p->b == NULL) p->b = &p->data[current];
        else if(p->c == NULL) p->c = &p->data[current];
        else /* error */;
      }
    else
      {
        p->data[current] = i;
      }
  }

The type of each len_partN should be a type that can count up to the length of partN. E.g.:

typedef struct parsedPacket_struct {
  char partA[300];unsigned short len_partA; // unsigned shorts have < 32k distinct values
  char partB[300];unsigned short len_partB; 
  char partC[300];unsigned short len_partC; 
}parsedPacket;

This seems like a design decision. If you want the struct to be easy to create, use the above approach, but beware its drawbacks (like "what if B has more than 300 chars?").