* @return a bool value

  char file_lastpurge[MP];
  sprintf (file_lastpurge, "%s%s", HOMEDIR, PURGE_DAY_FILE);

  bufchk (file_lastpurge, MP);

  if (exists (file_lastpurge))
  {
     fp = fopen (file_lastpurge, "r");

if (fp = fopen(file_lastpurge, "r"))
{
  // exists and readable
}
else
{
  // doesn't exist or is unreadable for some reason
}

/*!
 * Called in @ref main() to determine whether or not @ref purge() was run today, reads
 * and writes to the 'lastpurge` file. If it hasn't been run today, the
 * current day will be written. If 'lastpurge' doesn't exist, it gets
 * created.
 * @return FALSE if the day is the same (don't purge); otherwise TRUE and
 * writes the current day to 'lastpurge'
 */
bool
is_time_to_purge (void)
{
  int req_len = strlen (HOMEDIR) + strlen (PURGE_DAY_FILE) + 1;
  char file_lastpurge[req_len];
  snprintf (file_lastpurge, req_len, "%s%s", HOMEDIR, PURGE_DAY_FILE);

  char today_dd[3];
  get_time_string (today_dd, 3, "%d");

  FILE *fp = fopen (file_lastpurge, "r");

  if (fp)
  {
    char last_purge_dd[3];

    if (fgets (last_purge_dd, sizeof (last_purge_dd), fp) == NULL)
    {
      print_msg_error ();
      printf ("while getting line from %s\n", file_lastpurge);
      perror (__func__);
      close_file (fp, file_lastpurge, __func__);
      exit (ERR_FGETS);
    }

    bufchk (last_purge_dd, 3);
    trim_white_space (last_purge_dd);

    close_file (fp, file_lastpurge, __func__);

    /*
     * if these are the same, purge has already been run today
     */

    if (!strcmp (today_dd, last_purge_dd))
      return FALSE;
  }

  bool init = exists(file_lastpurge);
  fp = fopen (file_lastpurge, "w");
  if (fp)
  {
    fprintf (fp, "%s\n", today_dd);
    close_file (fp, file_lastpurge, __func__);

    /*
     * if this is the first time the file got created, it's very likely
     * indeed that purge does not need to run. Only return FALSE if the
     * file didn't previously exist.
     */
    return init;
  }

  /*
   * pretty sure the stream should be closed (free the pointer)
   * even if it's returned NULL
   */
  close_file (fp, file_lastpurge, __func__);

  /*
   * if we can't even write this file to the config directory, something
   * is not right. Make it fatal.
   */
  open_err (file_lastpurge, __func__);
  msg_return_code (ERR_OPEN);
  exit (ERR_OPEN);
}

  FILE *fp = fopen (file_lastpurge, "r");
  bool init = (fp != NULL);

/*!
 * Verify that *str doesn't exceed boundary, otherwise exit with an error code
 * @param[in] str The string to check
 * @param[in] boundary boundary
 * @return void
 * @see msg_err_buffer_overrun
 * @see bufchk_len
 */
void
bufchk (const char *str, ushort boundary)
{
  entry_NULL_check (str, __func__);

  /* STR_PART defines the first n characters of the string to display.
   * This assumes 10 will never exceed a buffer size. In this program,
   * there are no buffers that are <= 10 (that I can think of right now)
   */
#define STR_PART 10

  static ushort len;
  len = strlen (str);

  if (len < boundary)
    return;

#ifdef TEST_LIB
  errno = 1;
  return;
#endif

  print_msg_error ();
  /*
   * For now, using arbitrary arguments instead of changing every call to bufchk
   */
  msg_err_buffer_overrun ("unknown", 0);

  /*
   * This will add a null terminator within the boundary specified by
   * display_len, making it possible to view part of the strings to help
   * with debugging or tracing the error.
   */
  static ushort display_len;
  display_len = 0;

  display_len = (boundary > STR_PART) ? STR_PART : boundary;

  char temp[display_len];
  strncpy (temp, str, display_len);
  temp[display_len - 1] = '\0';

  /* Though we've set STR_PART to 10, we don't really know what's "safe",
   * so only display this if verbosity is on
   */
  if (verbose)
  {
    fprintf (stderr,
             _
             (" <--> Displaying part of the string that caused the error <-->\n\n"));
    fprintf (stderr, "%s\n\n", temp);
  }

  msg_return_code (EXIT_BUF_ERR);
  exit (EXIT_BUF_ERR);
}

/*!
 * Verify that len doesn't exceed boundary, otherwise exit with an error code.
 * Usually used before concatenating 2 or more strings. Program will exit
 * with an error code if len exceeds boundary. len should already have space
 * for the null terminator when this function is called.
 * @param[in] len The string to check
 * @param[in] boundary boundary
 * @param[in] func The calling function
 * @param[in] line The line number from where the function was called
 * @return void
 * @see msg_err_buffer_overrun
 * @see bufchk
 */
void
bufchk_len (const int len, const int boundary, const char *func, const int line)
{
  if (len <= boundary)
    return;

#ifdef TEST_LIB
  errno = 1;
  return;
#endif

  print_msg_error ();
  msg_err_buffer_overrun (func, line);
  exit (EXIT_BUF_ERR);
}

/*!
 * Get the combined length of multiple strings.
 *
 * @param[in] argc The number of arguments
 * @param[in] ... variable argument list, each argument should be a string
 * @return the combined length of each string
 */
int
multi_strlen (int argc, ...)
{
  va_list vlist;
  int len = 0;
  int i;
  va_start (vlist, argc);
  for (i = 0; i < argc; i++)
    len += strlen (va_arg (vlist, char*));
  va_end(vlist);
  return len;
}

/*!
 * Used by functions that prevent buffer overflows
 * @param[in] func the function from which it was originally called
 * @param[in] line the line number of the original calling function
 * @return void
 * @see bufchk
 * @see bufchk_len
 */
void
msg_err_buffer_overrun (const char *func, const int line)
{
  fprintf (stderr, "func = %s, line = %d\n", func, line);
  /* TRANSLATORS:  "buffer" in the following instances refers to the amount
   * of memory allocated for a string  */
  fputs (_("buffer overrun (segmentation fault) prevented.\n"), stderr);
  fputs (_("If you think this may be a bug, please report it to the rmw developers.\n"), stderr);
}

/** Some system don't define PATH_MAX. A limit needs to be set however,
 * and if it's not defined in a system header file, define it here
 */
#ifndef PATH_MAX /* for portability */
#  define PATH_MAX 256
#endif

#define MP (PATH_MAX + 1)

typedef struct st_waste st_waste;

/** Each waste directory is added to a linked list and has the data
 * from this structure associated with it.
 */
struct st_waste{
  /** The parent directory, e.g. $HOME/.local/share/Trash */
  char parent[PATH_MAX + 1];

  /*! The info directory (where .trashinfo files are written) will be appended to the parent directory */
  char info[PATH_MAX + 1];

  /** Appended to the parent directory, where files are moved to when they are rmw'ed
   */
  char files[PATH_MAX + 1];

  /** The device number of the filesystem on which the file resides. rmw does
   * not copy files from one filesystem to another, but rather only moves them.
   * They must reside on the same filesystem as a WASTE folder specified in
   * the configuration file.
   */
  unsigned int dev_num;

  /** set to <tt>true</tt> if the parent directory is on a removable device,
   * <tt>false</tt> otherwise.
   */
  bool removable;

  /** Points to the previous WASTE directory in the linked list
   */
  st_waste *prev_node;

  /** Points to the next WASTE directory in the linked list
   */
  st_waste *next_node;
};