/* gfileutils.c - File utility functions

 *

 *  Copyright 2000 Red Hat, Inc.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public License

 * along with this library; if not, see <http://www.gnu.org/licenses/>.

 */

#include "config.h"

#include "glibconfig.h"

#include <sys/stat.h>

#include <stdio.h>

#include <stdlib.h>

#include <stdarg.h>

#include <string.h>

#include <errno.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <stdlib.h>

#ifdef G_OS_UNIX

#include <unistd.h>

#endif

#ifdef G_OS_WIN32

#include <windows.h>

#include <io.h>

#endif /* G_OS_WIN32 */

#ifndef S_ISLNK

#define S_ISLNK(x) 0

#endif

#ifndef O_BINARY

#define O_BINARY 0

#endif

#include "gfileutils.h"

#include "gstdio.h"

#include "gstdioprivate.h"

#include "glibintl.h"

#ifdef HAVE_LINUX_MAGIC_H /* for btrfs check */

#include <linux/magic.h>

#include <sys/vfs.h>

#endif

/**

 * SECTION:fileutils

 * @title: File Utilities

 * @short_description: various file-related functions

 *

 * Do not use these APIs unless you are porting a POSIX application to Windows.

 * A more high-level file access API is provided as GIO — see the documentation

 * for #GFile.

 *

 * There is a group of functions which wrap the common POSIX functions

 * dealing with filenames (g_open(), g_rename(), g_mkdir(), g_stat(),

 * g_unlink(), g_remove(), g_fopen(), g_freopen()). The point of these

 * wrappers is to make it possible to handle file names with any Unicode

 * characters in them on Windows without having to use ifdefs and the

 * wide character API in the application code.

 *

 * On some Unix systems, these APIs may be defined as identical to their POSIX

 * counterparts. For this reason, you must check for and include the necessary

 * header files (such as `fcntl.h`) before using functions like g_creat(). You

 * must also define the relevant feature test macros.

 *

 * The pathname argument should be in the GLib file name encoding.

 * On POSIX this is the actual on-disk encoding which might correspond

 * to the locale settings of the process (or the `G_FILENAME_ENCODING`

 * environment variable), or not.

 *

 * On Windows the GLib file name encoding is UTF-8. Note that the

 * Microsoft C library does not use UTF-8, but has separate APIs for

 * current system code page and wide characters (UTF-16). The GLib

 * wrappers call the wide character API if present (on modern Windows

 * systems), otherwise convert to/from the system code page.

 *

 * Another group of functions allows to open and read directories

 * in the GLib file name encoding. These are g_dir_open(),

 * g_dir_read_name(), g_dir_rewind(), g_dir_close().

 */

/**

 * GFileError:

 * @G_FILE_ERROR_EXIST: Operation not permitted; only the owner of

 *     the file (or other resource) or processes with special privileges

 *     can perform the operation.

 * @G_FILE_ERROR_ISDIR: File is a directory; you cannot open a directory

 *     for writing, or create or remove hard links to it.

 * @G_FILE_ERROR_ACCES: Permission denied; the file permissions do not

 *     allow the attempted operation.

 * @G_FILE_ERROR_NAMETOOLONG: Filename too long.

 * @G_FILE_ERROR_NOENT: No such file or directory. This is a "file

 *     doesn't exist" error for ordinary files that are referenced in

 *     contexts where they are expected to already exist.

 * @G_FILE_ERROR_NOTDIR: A file that isn't a directory was specified when

 *     a directory is required.

 * @G_FILE_ERROR_NXIO: No such device or address. The system tried to

 *     use the device represented by a file you specified, and it

 *     couldn't find the device. This can mean that the device file was

 *     installed incorrectly, or that the physical device is missing or

 *     not correctly attached to the computer.

 * @G_FILE_ERROR_NODEV: The underlying file system of the specified file

 *     does not support memory mapping.

 * @G_FILE_ERROR_ROFS: The directory containing the new link can't be

 *     modified because it's on a read-only file system.

 * @G_FILE_ERROR_TXTBSY: Text file busy.

 * @G_FILE_ERROR_FAULT: You passed in a pointer to bad memory.

 *     (GLib won't reliably return this, don't pass in pointers to bad

 *     memory.)

 * @G_FILE_ERROR_LOOP: Too many levels of symbolic links were encountered

 *     in looking up a file name. This often indicates a cycle of symbolic

 *     links.

 * @G_FILE_ERROR_NOSPC: No space left on device; write operation on a

 *     file failed because the disk is full.

 * @G_FILE_ERROR_NOMEM: No memory available. The system cannot allocate

 *     more virtual memory because its capacity is full.

 * @G_FILE_ERROR_MFILE: The current process has too many files open and

 *     can't open any more. Duplicate descriptors do count toward this

 *     limit.

 * @G_FILE_ERROR_NFILE: There are too many distinct file openings in the

 *     entire system.

 * @G_FILE_ERROR_BADF: Bad file descriptor; for example, I/O on a

 *     descriptor that has been closed or reading from a descriptor open

 *     only for writing (or vice versa).

 * @G_FILE_ERROR_INVAL: Invalid argument. This is used to indicate

 *     various kinds of problems with passing the wrong argument to a

 *     library function.

 * @G_FILE_ERROR_PIPE: Broken pipe; there is no process reading from the

 *     other end of a pipe. Every library function that returns this

 *     error code also generates a 'SIGPIPE' signal; this signal

 *     terminates the program if not handled or blocked. Thus, your

 *     program will never actually see this code unless it has handled

 *     or blocked 'SIGPIPE'.

 * @G_FILE_ERROR_AGAIN: Resource temporarily unavailable; the call might

 *     work if you try again later.

 * @G_FILE_ERROR_INTR: Interrupted function call; an asynchronous signal

 *     occurred and prevented completion of the call. When this

 *     happens, you should try the call again.

 * @G_FILE_ERROR_IO: Input/output error; usually used for physical read

 *    or write errors. i.e. the disk or other physical device hardware

 *    is returning errors.

 * @G_FILE_ERROR_PERM: Operation not permitted; only the owner of the

 *    file (or other resource) or processes with special privileges can

 *    perform the operation.

 * @G_FILE_ERROR_NOSYS: Function not implemented; this indicates that

 *    the system is missing some functionality.

 * @G_FILE_ERROR_FAILED: Does not correspond to a UNIX error code; this

 *    is the standard "failed for unspecified reason" error code present

 *    in all #GError error code enumerations. Returned if no specific

 *    code applies.

 *

 * Values corresponding to @errno codes returned from file operations

 * on UNIX. Unlike @errno codes, GFileError values are available on

 * all systems, even Windows. The exact meaning of each code depends

 * on what sort of file operation you were performing; the UNIX

 * documentation gives more details. The following error code descriptions

 * come from the GNU C Library manual, and are under the copyright

 * of that manual.

 *

 * It's not very portable to make detailed assumptions about exactly

 * which errors will be returned from a given operation. Some errors

 * don't occur on some systems, etc., sometimes there are subtle

 * differences in when a system will report a given error, etc.

 */

/**

 * G_FILE_ERROR:

 *

 * Error domain for file operations. Errors in this domain will

 * be from the #GFileError enumeration. See #GError for information

 * on error domains.

 */

/**

 * GFileTest:

 * @G_FILE_TEST_IS_REGULAR: %TRUE if the file is a regular file

 *     (not a directory). Note that this test will also return %TRUE

 *     if the tested file is a symlink to a regular file.

 * @G_FILE_TEST_IS_SYMLINK: %TRUE if the file is a symlink.

 * @G_FILE_TEST_IS_DIR: %TRUE if the file is a directory.

 * @G_FILE_TEST_IS_EXECUTABLE: %TRUE if the file is executable.

 * @G_FILE_TEST_EXISTS: %TRUE if the file exists. It may or may not

 *     be a regular file.

 *

 * A test to perform on a file using g_file_test().

 */

/**

 * g_mkdir_with_parents:

 * @pathname: (type filename): a pathname in the GLib file name encoding

 * @mode: permissions to use for newly created directories

 *

 * Create a directory if it doesn't already exist. Create intermediate

 * parent directories as needed, too.

 *

 * Returns: 0 if the directory already exists, or was successfully

 * created. Returns -1 if an error occurred, with errno set.

 *

 * Since: 2.8

 */

int

g_mkdir_with_parents (const gchar *pathname,

		      int          mode)

{

  gchar *fn, *p;

  if (pathname == NULL || *pathname == '\0')

    {

      errno = EINVAL;

      return -1;

    }

  fn = g_strdup (pathname);

  if (g_path_is_absolute (fn))

    p = (gchar *) g_path_skip_root (fn);

  else

    p = fn;

  do

    {

      while (*p && !G_IS_DIR_SEPARATOR (*p))

	p++;

      if (!*p)

	p = NULL;

      else

	*p = '\0';

      if (!g_file_test (fn, G_FILE_TEST_EXISTS))

	{

	  if (g_mkdir (fn, mode) == -1 && errno != EEXIST)

	    {

	      int errno_save = errno;

	      g_free (fn);

	      errno = errno_save;

	      return -1;

	    }

	}

      else if (!g_file_test (fn, G_FILE_TEST_IS_DIR))

	{

	  g_free (fn);

	  errno = ENOTDIR;

	  return -1;

	}

      if (p)

	{

	  *p++ = G_DIR_SEPARATOR;

	  while (*p && G_IS_DIR_SEPARATOR (*p))

	    p++;

	}

    }

  while (p);

  g_free (fn);

  return 0;

}

/**

 * g_file_test:

 * @filename: (type filename): a filename to test in the

 *     GLib file name encoding

 * @test: bitfield of #GFileTest flags

 * 

 * Returns %TRUE if any of the tests in the bitfield @test are

 * %TRUE. For example, `(G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR)`

 * will return %TRUE if the file exists; the check whether it's a

 * directory doesn't matter since the existence test is %TRUE. With

 * the current set of available tests, there's no point passing in

 * more than one test at a time.

 * 

 * Apart from %G_FILE_TEST_IS_SYMLINK all tests follow symbolic links,

 * so for a symbolic link to a regular file g_file_test() will return

 * %TRUE for both %G_FILE_TEST_IS_SYMLINK and %G_FILE_TEST_IS_REGULAR.

 *

 * Note, that for a dangling symbolic link g_file_test() will return

 * %TRUE for %G_FILE_TEST_IS_SYMLINK and %FALSE for all other flags.

 *

 * You should never use g_file_test() to test whether it is safe

 * to perform an operation, because there is always the possibility

 * of the condition changing before you actually perform the operation.

 * For example, you might think you could use %G_FILE_TEST_IS_SYMLINK

 * to know whether it is safe to write to a file without being

 * tricked into writing into a different location. It doesn't work!

 * |[

 *  // DON'T DO THIS

 *  if (!g_file_test (filename, G_FILE_TEST_IS_SYMLINK)) 

 *    {

 *      fd = g_open (filename, O_WRONLY);

 *      // write to fd

 *    }

 * ]|

 *

 * Another thing to note is that %G_FILE_TEST_EXISTS and

 * %G_FILE_TEST_IS_EXECUTABLE are implemented using the access()

 * system call. This usually doesn't matter, but if your program

 * is setuid or setgid it means that these tests will give you

 * the answer for the real user ID and group ID, rather than the

 * effective user ID and group ID.

 *

 * On Windows, there are no symlinks, so testing for

 * %G_FILE_TEST_IS_SYMLINK will always return %FALSE. Testing for

 * %G_FILE_TEST_IS_EXECUTABLE will just check that the file exists and

 * its name indicates that it is executable, checking for well-known

 * extensions and those listed in the `PATHEXT` environment variable.

 *

 * Returns: whether a test was %TRUE

 **/

gboolean

g_file_test (const gchar *filename,

             GFileTest    test)

{

#ifdef G_OS_WIN32

  int attributes;

  wchar_t *wfilename;

#endif

  g_return_val_if_fail (filename != NULL, FALSE);

#ifdef G_OS_WIN32

/* stuff missing in std vc6 api */

#  ifndef INVALID_FILE_ATTRIBUTES

#    define INVALID_FILE_ATTRIBUTES -1

#  endif

#  ifndef FILE_ATTRIBUTE_DEVICE

#    define FILE_ATTRIBUTE_DEVICE 64

#  endif

  wfilename = g_utf8_to_utf16 (filename, -1, NULL, NULL, NULL);

  if (wfilename == NULL)

    return FALSE;

  attributes = GetFileAttributesW (wfilename);

  g_free (wfilename);

  if (attributes == INVALID_FILE_ATTRIBUTES)

    return FALSE;

  if (test & G_FILE_TEST_EXISTS)

    return TRUE;

  if (test & G_FILE_TEST_IS_REGULAR)

    {

      if ((attributes & (FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_DEVICE)) == 0)

	return TRUE;

    }

  if (test & G_FILE_TEST_IS_DIR)

    {

      if ((attributes & FILE_ATTRIBUTE_DIRECTORY) != 0)

	return TRUE;

    }

  /* "while" so that we can exit this "loop" with a simple "break" */

  while (test & G_FILE_TEST_IS_EXECUTABLE)

    {

      const gchar *lastdot = strrchr (filename, '.');

      const gchar *pathext = NULL, *p;

      int extlen;

      if (lastdot == NULL)

        break;

      if (_stricmp (lastdot, ".exe") == 0 ||

	  _stricmp (lastdot, ".cmd") == 0 ||

	  _stricmp (lastdot, ".bat") == 0 ||

	  _stricmp (lastdot, ".com") == 0)

	return TRUE;

      /* Check if it is one of the types listed in %PATHEXT% */

      pathext = g_getenv ("PATHEXT");

      if (pathext == NULL)

        break;

      pathext = g_utf8_casefold (pathext, -1);

      lastdot = g_utf8_casefold (lastdot, -1);

      extlen = strlen (lastdot);

      p = pathext;

      while (TRUE)

	{

	  const gchar *q = strchr (p, ';');

	  if (q == NULL)

	    q = p + strlen (p);

	  if (extlen == q - p &&

	      memcmp (lastdot, p, extlen) == 0)

	    {

	      g_free ((gchar *) pathext);

	      g_free ((gchar *) lastdot);

	      return TRUE;

	    }

	  if (*q)

	    p = q + 1;

	  else

	    break;

	}

      g_free ((gchar *) pathext);

      g_free ((gchar *) lastdot);

      break;

    }

  return FALSE;

#else

  if ((test & G_FILE_TEST_EXISTS) && (access (filename, F_OK) == 0))

    return TRUE;

  if ((test & G_FILE_TEST_IS_EXECUTABLE) && (access (filename, X_OK) == 0))

    {

      if (getuid () != 0)

	return TRUE;

      /* For root, on some POSIX systems, access (filename, X_OK)

       * will succeed even if no executable bits are set on the

       * file. We fall through to a stat test to avoid that.

       */

    }

  else

    test &= ~G_FILE_TEST_IS_EXECUTABLE;

  if (test & G_FILE_TEST_IS_SYMLINK)

    {

      struct stat s;

      if ((lstat (filename, &s) == 0) && S_ISLNK (s.st_mode))

        return TRUE;

    }

  if (test & (G_FILE_TEST_IS_REGULAR |

	      G_FILE_TEST_IS_DIR |

	      G_FILE_TEST_IS_EXECUTABLE))

    {

      struct stat s;

      if (stat (filename, &s) == 0)

	{

	  if ((test & G_FILE_TEST_IS_REGULAR) && S_ISREG (s.st_mode))

	    return TRUE;

	  if ((test & G_FILE_TEST_IS_DIR) && S_ISDIR (s.st_mode))

	    return TRUE;

	  /* The extra test for root when access (file, X_OK) succeeds.

	   */

	  if ((test & G_FILE_TEST_IS_EXECUTABLE) &&

	      ((s.st_mode & S_IXOTH) ||

	       (s.st_mode & S_IXUSR) ||

	       (s.st_mode & S_IXGRP)))

	    return TRUE;

	}

    }

  return FALSE;

#endif

}

G_DEFINE_QUARK (g-file-error-quark, g_file_error)

/**

 * g_file_error_from_errno:

 * @err_no: an "errno" value

 * 

 * Gets a #GFileError constant based on the passed-in @err_no.

 * For example, if you pass in `EEXIST` this function returns

 * #G_FILE_ERROR_EXIST. Unlike `errno` values, you can portably

 * assume that all #GFileError values will exist.

 *

 * Normally a #GFileError value goes into a #GError returned

 * from a function that manipulates files. So you would use

 * g_file_error_from_errno() when constructing a #GError.

 * 

 * Returns: #GFileError corresponding to the given @errno

 **/

GFileError

g_file_error_from_errno (gint err_no)

{

  switch (err_no)

    {

#ifdef EEXIST

    case EEXIST:

      return G_FILE_ERROR_EXIST;

#endif

#ifdef EISDIR

    case EISDIR:

      return G_FILE_ERROR_ISDIR;

#endif

#ifdef EACCES

    case EACCES:

      return G_FILE_ERROR_ACCES;

#endif

#ifdef ENAMETOOLONG

    case ENAMETOOLONG:

      return G_FILE_ERROR_NAMETOOLONG;

#endif

#ifdef ENOENT

    case ENOENT:

      return G_FILE_ERROR_NOENT;

#endif

#ifdef ENOTDIR

    case ENOTDIR:

      return G_FILE_ERROR_NOTDIR;

#endif

#ifdef ENXIO

    case ENXIO:

      return G_FILE_ERROR_NXIO;

#endif

#ifdef ENODEV

    case ENODEV:

      return G_FILE_ERROR_NODEV;

#endif

#ifdef EROFS

    case EROFS:

      return G_FILE_ERROR_ROFS;

#endif

#ifdef ETXTBSY

    case ETXTBSY:

      return G_FILE_ERROR_TXTBSY;

#endif

#ifdef EFAULT

    case EFAULT:

      return G_FILE_ERROR_FAULT;

#endif

#ifdef ELOOP

    case ELOOP:

      return G_FILE_ERROR_LOOP;

#endif

#ifdef ENOSPC

    case ENOSPC:

      return G_FILE_ERROR_NOSPC;

#endif

#ifdef ENOMEM

    case ENOMEM:

      return G_FILE_ERROR_NOMEM;

#endif

#ifdef EMFILE

    case EMFILE:

      return G_FILE_ERROR_MFILE;

#endif

#ifdef ENFILE

    case ENFILE:

      return G_FILE_ERROR_NFILE;

#endif

#ifdef EBADF

    case EBADF:

      return G_FILE_ERROR_BADF;

#endif

#ifdef EINVAL

    case EINVAL:

      return G_FILE_ERROR_INVAL;

#endif

#ifdef EPIPE

    case EPIPE:

      return G_FILE_ERROR_PIPE;

#endif

#ifdef EAGAIN

    case EAGAIN:

      return G_FILE_ERROR_AGAIN;

#endif

#ifdef EINTR

    case EINTR:

      return G_FILE_ERROR_INTR;

#endif

#ifdef EIO

    case EIO:

      return G_FILE_ERROR_IO;

#endif

#ifdef EPERM

    case EPERM:

      return G_FILE_ERROR_PERM;

#endif

#ifdef ENOSYS

    case ENOSYS:

      return G_FILE_ERROR_NOSYS;

#endif

    default:

      return G_FILE_ERROR_FAILED;

    }

}

static char *

format_error_message (const gchar  *filename,

                      const gchar  *format_string,

                      int           saved_errno) G_GNUC_FORMAT(2);

#pragma GCC diagnostic push

#pragma GCC diagnostic ignored "-Wformat-nonliteral"

static char *

format_error_message (const gchar  *filename,

                      const gchar  *format_string,

                      int           saved_errno)

{

  gchar *display_name;

  gchar *msg;

  display_name = g_filename_display_name (filename);

  msg = g_strdup_printf (format_string, display_name, g_strerror (saved_errno));

  g_free (display_name);

  return msg;

}

#pragma GCC diagnostic pop

/* format string must have two '%s':

 *

 *   - the place for the filename

 *   - the place for the strerror

 */

static void

set_file_error (GError      **error,

                const gchar  *filename,

                const gchar  *format_string,

                int           saved_errno)

{

  char *msg = format_error_message (filename, format_string, saved_errno);

  g_set_error_literal (error, G_FILE_ERROR, g_file_error_from_errno (saved_errno),

                       msg);

  g_free (msg);

}

static gboolean

get_contents_stdio (const gchar  *filename,

                    FILE         *f,

                    gchar       **contents,

                    gsize        *length,

                    GError      **error)

{

  gchar buf[4096];

  gsize bytes;  /* always <= sizeof(buf) */

  gchar *str = NULL;

  gsize total_bytes = 0;

  gsize total_allocated = 0;

  gchar *tmp;

  gchar *display_filename;

  g_assert (f != NULL);

  while (!feof (f))

    {

      gint save_errno;

      bytes = fread (buf, 1, sizeof (buf), f);

      save_errno = errno;

      if (total_bytes > G_MAXSIZE - bytes)

          goto file_too_large;

      /* Possibility of overflow eliminated above. */

      while (total_bytes + bytes >= total_allocated)

        {

          if (str)

            {

              if (total_allocated > G_MAXSIZE / 2)

                  goto file_too_large;

              total_allocated *= 2;

            }

          else

            {

              total_allocated = MIN (bytes + 1, sizeof (buf));

            }

          tmp = g_try_realloc (str, total_allocated);

          if (tmp == NULL)

            {

              display_filename = g_filename_display_name (filename);

              g_set_error (error,

                           G_FILE_ERROR,

                           G_FILE_ERROR_NOMEM,

                           g_dngettext (GETTEXT_PACKAGE, "Could not allocate %lu byte to read file “%s”", "Could not allocate %lu bytes to read file “%s”", (gulong)total_allocated),

                           (gulong) total_allocated,

			   display_filename);

              g_free (display_filename);

              goto error;

            }

	  str = tmp;

        }

      if (ferror (f))

        {

          display_filename = g_filename_display_name (filename);

          g_set_error (error,

                       G_FILE_ERROR,

                       g_file_error_from_errno (save_errno),

                       _("Error reading file “%s”: %s"),

                       display_filename,

		       g_strerror (save_errno));

          g_free (display_filename);

          goto error;

        }

      g_assert (str != NULL);

      memcpy (str + total_bytes, buf, bytes);

      total_bytes += bytes;

    }

  fclose (f);

  if (total_allocated == 0)

    {

      str = g_new (gchar, 1);

      total_bytes = 0;

    }

  str[total_bytes] = '\0';

  if (length)

    *length = total_bytes;

  *contents = str;

  return TRUE;

 file_too_large:

  display_filename = g_filename_display_name (filename);

  g_set_error (error,

               G_FILE_ERROR,

               G_FILE_ERROR_FAILED,

               _("File “%s” is too large"),

               display_filename);

  g_free (display_filename);

 error:

  g_free (str);

  fclose (f);

  return FALSE;

}

#ifndef G_OS_WIN32

static gboolean

get_contents_regfile (const gchar  *filename,

                      struct stat  *stat_buf,

                      gint          fd,

                      gchar       **contents,

                      gsize        *length,

                      GError      **error)

{

  gchar *buf;

  gsize bytes_read;

  gsize size;

  gsize alloc_size;

  gchar *display_filename;

  size = stat_buf->st_size;

  alloc_size = size + 1;

  buf = g_try_malloc (alloc_size);

  if (buf == NULL)

    {

      display_filename = g_filename_display_name (filename);

      g_set_error (error,

                   G_FILE_ERROR,

                   G_FILE_ERROR_NOMEM,

                           g_dngettext (GETTEXT_PACKAGE, "Could not allocate %lu byte to read file “%s”", "Could not allocate %lu bytes to read file “%s”", (gulong)alloc_size),

                   (gulong) alloc_size, 

		   display_filename);

      g_free (display_filename);

      goto error;

    }

  bytes_read = 0;

  while (bytes_read < size)

    {

      gssize rc;

      rc = read (fd, buf + bytes_read, size - bytes_read);

      if (rc < 0)

        {

          if (errno != EINTR) 

            {

	      int save_errno = errno;

              g_free (buf);

              display_filename = g_filename_display_name (filename);

              g_set_error (error,

                           G_FILE_ERROR,

                           g_file_error_from_errno (save_errno),

                           _("Failed to read from file “%s”: %s"),

                           display_filename, 

			   g_strerror (save_errno));

              g_free (display_filename);

	      goto error;

            }

        }

      else if (rc == 0)

        break;

      else

        bytes_read += rc;

    }

  buf[bytes_read] = '\0';

  if (length)

    *length = bytes_read;

  *contents = buf;

  close (fd);

  return TRUE;

 error:

  close (fd);

  return FALSE;

}

static gboolean

get_contents_posix (const gchar  *filename,

                    gchar       **contents,

                    gsize        *length,

                    GError      **error)

{

  struct stat stat_buf;

  gint fd;

  /* O_BINARY useful on Cygwin */

  fd = open (filename, O_RDONLY|O_BINARY);

  if (fd < 0)

    {

      int saved_errno = errno;

      set_file_error (error,

                      filename,