Page History

The C Standard, 6.7.3.2, paragraph 20 [ISO/IEC 9899:2024], says

As a special case, the last element of a structure with more than one named member may have an incomplete array type; this is called a flexible array member. In most situations, the flexible array member is ignored.

Flexible array members are a special type of array where the last element of a structure with more than one named member has an incomplete array type; that is, the size of the array is not specified explicitly within the structure.  A variety of different syntaxes have been used for declaring flexible array members.  For C99-compliant implementations, use the syntax guaranteed valid by C99 \[[ISO/IEC 9899:1999|AA. C References#ISO/IEC 9899-1999]\]. Section 6.7.2.1, paragraph 16: "Structure and Union Specifiers", says:

In particular, the size of the structure is as if the flexible array member were omitted except that it may have more trailing padding than the omission would imply.

Noncompliant Code Example (Declaration)

The following is an example of a structure that contains a flexible array member:

struct flex_array_struct {
  int num;
  int data[];
};

This definition means that when computing the size of such a structure, only the first member, num, is considered. Unless the appropriate size of the flexible array member has been explicitly added when allocating storage for an object of the struct, the result of accessing the member data of a variable of nonpointer type struct flex_array_struct is undefined. DCL38-C. Use the correct syntax when declaring a flexible array member describes the correct way to declare a struct with a flexible array member.

To avoid the potential for undefined behavior, structures that contain a flexible array member should always be allocated dynamically. Flexible array structures must

• Have dynamic storage duration (be allocated via malloc() or another dynamic allocation function)
• Be dynamically copied using memcpy() or a similar function and not by assignment
• When used as an argument to a function, be passed by pointer and not copied by value

Noncompliant Code Example (Storage Duration)

This noncompliant code example uses automatic storage for a structure containing a flexible array member:In this noncompliant code, an array of size 1 is declared, but when the structure itself is instantiated, the size computed for malloc() is modified to account for the actual size of the dynamic array. This is the syntax used by ISO C89.

#include <stddef.h>
 
struct flexArrayStructflex_array_struct {
  intsize_t num;
  int data[1];
};
 
/* ... */

size_t array_size;
size_t i;

/* initialize array_size */

/* space is allocated for the struct */
struct flexArrayStruct *structP
  = (struct flexArrayStruct *)
     malloc(sizeof(struct flexArrayStruct)
          + sizeof(int) * (array_size - 1));
if (structP == NULL) {void func(void) {
  struct flex_array_struct flex_struct;
  size_t array_size = 4;

  /* HandleInitialize malloc failurestructure */
}
structP->num  flex_struct.num = 0array_size;

/* access data[] as if it had been allocated
 * as data[array_size] */
for (for (size_t i = 0; i < array_size; i++i) {
  structP->data  flex_struct.data[i] = 10;
  }

The problem with this code is that the only member that is guaranteed to be valid, by strict C99 definition, is {{structP->data\[0\]}}. Consequently, for all {{i > 0}}, the results of the assignment are undefined.

Implementation Details

The noncompliant example may be the only alternative for compilers that do not yet implement the C99 syntax.  Microsoft Visual Studio 2005 does not implement the C99 syntax.

Compliant Solution (Declaration)

}

Because the memory for flex_struct is reserved on the stack, no space is reserved for the data member. Accessing the data member is undefined behavior.

Compliant Solution (Storage Duration)

This compliant solution dynamically allocates storage for flex_array_struct:This compliant solution uses the flexible array member to achieve a dynamically sized structure.

#include <stdlib.h>
 
struct flexArrayStructflex_array_struct {
  intsize_t num;
  int data[];
};
 
/* ... */

size_t array_size;
size_t i;

/* Initializevoid func(void) {
  struct flex_array_struct *flex_struct;
  size_t array_size */= 4;

  /* SpaceDynamically isallocate allocatedmemory for the struct */
struct flexArrayStruct *structPflex_struct = (struct flexArrayStructflex_array_struct *)malloc(
    malloc(sizeof(struct flexArrayStruct) flex_array_struct)
    + sizeof(int) * array_size);
  if (structPflex_struct == NULL) {
    /* Handle mallocerror failure */
  }

structP->num = 0;

/* AccessInitialize data[] as if it had been allocated
 * as data[array_size]
 */
for (structure */
  flex_struct->num = array_size;

  for (size_t i = 0; i < array_size; i++i) {
  structP  flex_struct->data[i] = 10;
  }

This compliant solution allows the structure to be treated as if it had declared the member {{data\[\]}} to be {{data\[array_size\]}} in a manner that conforms to the C99 standard.

However, some restrictions apply:

1. The incomplete array type must be the last element within the structure.
2. There cannot be an array of structures that contain flexible array members.
3. Structures that contain a flexible array member cannot be used as a member in the middle of another structure.
4. The sizeof operator cannot be applied to a flexible array.

Noncompliant Code Example (Declaration Example 2)

When using structures with a flexible array member you should never directly declare an instance of the structure.  The following code snippet illustrates this.

}

Noncompliant Code Example (Copying)

This noncompliant code example attempts to copy an instance of a structure containing a flexible array member (struct flex_array_struct) by assignment:

#include <stddef.h>
 
struct flex_array_struct flexArrayStruct{
  intsize_t num;
  int data[];
};
 
/* ... */

struct flexArrayStruct flexStruct;
size_t array_size;
size_t i;

/* Initialize array_size */

/* Initialize structure */
flexStruct.num = 0;

for (i = 0; i < array_size; i++void func(struct flex_array_struct *struct_a,
          struct flex_array_struct *struct_b) {
  flexStruct.data[i]*struct_b = 0*struct_a;
}

The problem with this code is that the flexArrayStruct does not actually reserve space for the integer array data - it can't as the size hasn't been specified.  Thus, while initializing the num member to zero is ok, attempting to write even one value into data (i.e. data\[0\]) will likely overwrite memory not owned by the structure.

Compliant Code Example (Declaration Example 2)

When the structure is copied, the size of the flexible array member is not considered, and only the first member of the structure, num, is copied, leaving the array contents untouched.

Compliant Solution (Copying)

This compliant solution uses memcpy() to properly copy the content of struct_a into struct_b:The solution is to always declare pointers to structures containing a flexible array member and dynamically allocate memory for them.  The following code snippet illustrates this.

#include <string.h>
 
struct flex_array_struct flexArrayStruct{
  intsize_t num;
  int data[];
};
 
/* ... */

struct flexArrayStruct *flexStruct;
size_t array_size;
size_t i;

/* Initialize array_size */

/* Dynamically allocate memory for the structure */
flexStruct = (struct flexArrayStruct *)
   malloc(sizeof(struct flexArrayStruct) + sizeof(int) * array_size);
if (flexStruct == NULL) {
  /* Handle malloc failure */
}

/* Initialize structure */
flexStruct->num = 0;

for (i = 0; i < array_size; i++) {
  flexStruct->data[i] = 0;
}

In this code snippet the resolves the issue by declaring a pointer to flexArrayStruct and then dynamically allocating memory for the pointer to point to.  In this case it is ok to access the elements of the data\[\] member as described in Section 6.7.2.1, paragraph 16.

Noncompliant Code Example (Reference)

void func(struct flex_array_struct *struct_a,
          struct flex_array_struct *struct_b) {
  if (struct_a->num > struct_b->num) {
    /* Insufficient space; handle error */
    return;
  }
  memcpy(struct_b, struct_a,
         sizeof(struct flex_array_struct) + (sizeof(int)
           * struct_a->num));
}

Noncompliant Code Example (Function Arguments)

In this noncompliant code exampleIn this noncompliant code, the flexible array structure is passed directly by value to a function which tries to print the array elements. This fails because passing the struct directly to the function actually makes a copy of the struct. When the struct is copied, the size of the flexible array member is not considered, consequently the array is truncated, and the function only has garbage in the array to print.that prints the array elements:

#include <stdio.h>
#include <stdlib.h>
 
struct flexArrayStructflex_array_struct {
  intsize_t num;
  int data[1];
};
 
void print_array(struct flex_array_struct flexArrayStruct structPstruct_p) {
  size_t i;
  printfputs("Array is: ");
  for (size_t i = 0; i < structPstruct_p.num; i++i) {
    printf("%d ", structPstruct_p.data[i]);
  }
  printfputchar("'\n"');
}


size_t array_size;
void func(void) {
  struct flex_array_struct *struct_p;
  size_t i;

/* initialize array_size */= 4;

  /* spaceSpace is allocated for the struct */
struct flexArrayStruct *structP
  struct_p = (struct flexArrayStructflex_array_struct *)malloc(
     malloc(sizeof(struct flexArrayStructflex_array_struct)
           + sizeof(int) * (array_size - 1));
  if (structPstruct_p == NULL) {
    /* Handle mallocerror failure */
  }
structP  struct_p->num = array_size;

  for (size_t i = 0; i < array_size; i++i) {
    structPstruct_p->data[i] = i;
  }

  print_array( *structPstruct_p);

Compliant Solution (Reference)

Never allow a flexible array member to be copied. The above code can be fixed by changing the function to accept a pointer to the flexible array struct.

}

Because the argument is passed by value, the size of the flexible array member is not considered when the structure is copied, and only the first member of the structure, num, is copied.

Compliant Solution (Function Arguments)

In this compliant solution, the structure is passed by reference and not by value:

#include <stdio.h>
#include <stdlib.h>
 
struct flexArrayStructflex_array_struct {
  intsize_t num;
  int data[];
};
 
void print_array(struct flex_array_struct flexArrayStruct* structPstruct_p) {
  size_t i;
  printfputs("Array is: ");
  for (size_t i = 0; i < structPstruct_p->num; i++i) {
    printf("%d ", structPstruct_p->data[i]);
  }
  printfputchar("'\n"');
}

/* ... */

size_t array_size = 10;
size_t i;

/* Initialize array_size */

/* Space is allocated for the struct */
struct flexArrayStruct *structP = (struct flexArrayStruct *)
  malloc(sizeof(struct flexArrayStruct) + sizeof(int) * array_size);
if (structP == NULL) {
  /* Handle malloc failure */
}

structP->num = array_size;

/* Access data[] as if it had been allocated
 * as data[array_size]
 */
for (i = 0; i < array_size; i++) {
  structP->data[i] = i;
}

print_array( structP);
return 0;

Risk Assessment

void func(void) {
  struct flex_array_struct *struct_p;
  size_t array_size = 4;

  /* Space is allocated for the struct and initialized... */

  print_array(struct_p);
}

Risk Assessment

Failure to use structures with flexible array members correctly can result in undefined behavior. Failing to use the correct syntax can result in undefined behavior, although the incorrect syntax will work on most implementations.

Automated Detection

...

...

Related Vulnerabilities

Search for vulnerabilities resulting from the violation of this rule on the CERT website.

References

\[[ISO/IEC 9899:1999|AA. C References#ISO/IEC 9899-1999]\] Section 6.7.2.1, "Structure and union specifiers"
\[[McCluskey 01|AA. C References#McCluskey 01]\] ;login:, July 2001, Volume 26, Number 4

Related Guidelines

Key here (explains table format and definitions)

CERT-CWE Mapping Notes

Key here for mapping notes

CWE-401 and MEM33-CPP

There is no longer a C++ rule for MEM33-CPP. (In fact, all C++ rules from 30-50 are gone, because we changed the numbering system to be 50-99 for C++ rules.)

Bibliography

...

Image Added Image Added MEM32-C. Detect and handle memory allocation errors      08. Memory Management (MEM)      Image Modified