Page History

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
 
enum { MAX_ALLOCATION = 1000 };

int main(int argc, const char *argv[]) {
  char *c_str = NULL;
  size_t len;

  if (argc == 2) {
    len = strlen(argv[1]) + 1;
    if (len > MAX_ALLOCATION) {
      /* Handle error */
    }
    c_str = (char *)malloc(len

Freeing memory that is not allocated dynamically can lead to serious errors. The specific consequences of this error depends on the compiler, but ranges from nothing to abnormal program termination. Regardless of the compiler, avoid calling {{free()}} on non-dynamic memory.

A similar situation arises when {{realloc()}} is supplied a pointer to non-dynamically allocated memory. The {{realloc()}} function is used to resize a block of dynamic memory. If {{realloc()}} is supplied a pointer to memory not allocated by a memory allocation function, such as{{malloc()}}, the program may also terminate abnormally.

h2. Non-compliant Code Example 1

The following piece of code validates the number of command line arguemnts. If the correct number of commmand line arguements have been specified, memory is allocated with {{malloc()}} and referenced by {{str}}. Next, the second command line argument is copied into {{str}} for further processing. Once this processing is complete, {{str}} is freed.However, if the incorrect number of arguments have been specified, {{str}} is set to a string literal and printed. Because {{str}} now references memory that was not dynamically allocated, an error will occur when {{str}} memory is freed.
{code}
int main(int argc, char *argv[]) {
  char *str = NULL;
  if (argc == 2) {
    str = malloc(strlen(argv[1]));
    if (c_str == NULL) {
      /* Handle Allocationerror Error */
    }
    strcpy(c_str, argv[1]);
  }
  else {
    c_str = "usage: $>a.exe [string]";
    printf("%s\n", c_str);
  }
  /* ... */
  free(c_str);
  return 0;
}
{code}

h2. Compliant Solution 1

In the compliant solution, theprogram has been changed to eliminate the possibility of {{str}} referencing non-dynamic memory and when it is supplied to {{free()}}.
{code}

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
 
enum { MAX_ALLOCATION = 1000 };

int main(int argc, const char *argv[]) {
  char *c_str = NULL;
  size_t len;

  if (argc == 2) {
    strlen = malloc(strlen(argv[1]) + 1;
    if (len > MAX_ALLOCATION) {
      /* Handle error */
    }
    c_str = (char *)malloc(len);
    if (c_str == NULL) {
      /* Handle Allocation Errorerror */
    }
    strcpy(c_str, argv[1]);
  }
  else {
    printf("%s\n", "usage: $>a.exe [string]\n");
    return 1EXIT_FAILURE;
  }
  /* ... */
  free(c_str);
  return 0;
}
{code}

h2. Non-compliant Code Example 2

This example attempts to resize the string referenced by {{buf}} to make enough room to append the string {{line}}. However, once in the function {{append()}}, there is no way to determine how {{buf}} was allocated. When {{realloc()}} is called on {{buf}}, since {{buf}} does not point to dynamic memory, an error may occur.
{code}
void append(char *buf, size_t count, size_t size) {

#include <stdlib.h>
 
enum { BUFSIZE = 256 };
 
void f(void) {
  char buf[BUFSIZE];
  char *linep = " <- THIS IS A LINE";
  int line_len = strlen(line);

(char *)realloc(buf, 2 * BUFSIZE);
  if ((countp + line_len== NULL) >{
 size)
   /* bufHandle = realloc(buf,count+line_len);error */
  strcat(buf,line);}
}

h2. 

#include <stdlib.h>
 
enum { BUFSIZE = 256 };
 
void f(void) {
  char *buf = (char *)malloc(BUFSIZE * sizeof(char));
  char *p = (char *)realloc(buf, 2 * BUFSIZE);
  if (p == NULL) {
    /* Handle error */
  }
}