Errors and Resource Allocation

• Often, when a system call fails, it's appropriate to cancel the current operation but not to terminate the program because it may be possible to recover from the error.
• One way to do this is to return from the current function, passing a return code to the caller indicating the error.
• If you decide to return from the middle of a function, it's important to make sure that any resources successfully allocated previously in the function are first deallocated.
• Otherwise, if your program continues running, the resources allocated before the failure occurred will be leaked.
• Consider, for example, a function that reads from a file into a buffer.The function might follow these steps:
  1. Locate the buffer.
  2. Open the file.
  3. Read from the file into the buffer.
  4. Close the file.
  5. Return the buffer.
  http://siber.cankaya.edu.tr/SystemsProgramming/cfiles/readfile.creadfile.c

  #include <fcntl.h>
  #include <stdlib.h>
  #include <sys/stat.h>
  #include <sys/types.h>
  #include <unistd.h>
  
  char* read_from_file (const char* filename, size_t length)
  {
    char* buffer;
    int fd;
    ssize_t bytes_read;
  
    /* Allocate the buffer.  */
    buffer = (char*) malloc (length);
    if (buffer == NULL)
      return NULL;
    /* Open the file.  */
    fd = open (filename, O_RDONLY);
    if (fd == -1) {
      /* open failed.  Deallocate buffer before returning.  */
      free (buffer);
      return NULL;
    }
    /* Read the data.  */
    bytes_read = read (fd, buffer, length);
    if (bytes_read != length) {
      /* read failed.  Deallocate buffer and close fd before returning.  */
      free (buffer);
      close (fd);
      return NULL;
    }
    /* Everything's fine.  Close the file and return the buffer.  */
    close (fd);
    return buffer;
  }
  

• Linux cleans up allocated memory, open files, and most other resources when a program terminates, so it's not necessary to deallocate buffers and close files before calling exit.
• You might need to manually free other shared resources, however, such as temporary files and shared memory, which can potentially outlive a program.