Using Temporary Files

• Sometimes a program needs to make a temporary file, to store large data for a while or to pass data to another program.
• On GNU/Linux systems, temporary files are stored in the /tmp directory. When using temporary files, you should be aware of the following pitfalls:
  • More than one instance of your program may be run simultaneously (by the same user or by different users).The instances should use different temporary filenames so that they don't collide.
  • The file permissions of the temporary file should be set in such a way that unauthorized users cannot alter the program's execution by modifying or replacing the temporary file.
  • Temporary filenames should be generated in a way that cannot be predicted externally; otherwise, an attacker can exploit the delay between testing whether a given name is already in use and opening a new temporary file.
• GNU/Linux provides functions, mkstemp and tmpfile, that take care of these issues for you
• Using mkstemp
  • The mkstemp function creates a unique temporary filename from a filename template, creates the file with permissions so that only the current user can access it, and opens the file for read/write.
  • The filename template is a character string ending with "XXXXXX" (six capital X's); mkstemp replaces the X's with characters so that the filename is unique.
  • The return value is a file descriptor; use the write family of functions to write to the temporary file. http://siber.cankaya.edu.tr/SystemsProgramming/cfiles/temp_file.ctemp_file.c

    #include <stdlib.h>
    #include <unistd.h>
    
    /* A handle for a temporary file created with write_temp_file.  In
       this implementation, it's just a file descriptor.  */
    typedef int temp_file_handle;
    
    /* Writes LENGTH bytes from BUFFER into a temporary file.  The
       temporary file is immediately unlinked.  Returns a handle to the
       temporary file.  */
    
    temp_file_handle write_temp_file (char* buffer, size_t length)
    {
      /* Create the filename and file.  The XXXXXX will be replaced with
         characters that make the filename unique.  */
      char temp_filename[] = "/tmp/temp_file.XXXXXX";
      int fd = mkstemp (temp_filename);
      /* Unlink the file immediately, so that it will be removed when the
         file descriptor is closed.  */
      unlink (temp_filename);
      /* Write the number of bytes to the file first.  */
      write (fd, &length, sizeof (length));
      /* Now write the data itself.  */
      write (fd, buffer, length);
      /* Use the file descriptor as the handle for the temporary file.  */
      return fd;
    }
    
    /* Reads the contents of a temporary file TEMP_FILE created with
       write_temp_file.  The return value is a newly-allocated buffer of
       those contents, which the caller must deallocate with free.
       *LENGTH is set to the size of the contents, in bytes.  The
       temporary file is removed.  */
    
    char* read_temp_file (temp_file_handle temp_file, size_t* length)
    {
      char* buffer;
      /* The TEMP_FILE handle is a file descriptor to the temporary file.  */
      int fd = temp_file;
      /* Rewind to the beginning of the file.  */
      lseek (fd, 0, SEEK_SET);
      /* Read the size of the data in the temporary file.  */
      read (fd, length, sizeof (*length));
      /* Allocate a buffer and read the data.  */
      buffer = (char*) malloc (*length);
      read (fd, buffer, *length);
      /* Close the file descriptor, which will cause the temporary file to
         go away.  */
      close (fd);
      return buffer;
    }