/* GLIB - Library of useful routines for C programming

 * gmappedfile.c: Simplified wrapper around the mmap() function.

 *

 * Copyright 2005 Matthias Clasen

 *

 * SPDX-License-Identifier: LGPL-2.1-or-later

 *

 * 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 <errno.h>

#include <sys/types.h> 

#include <sys/stat.h> 

#include <fcntl.h>

#ifdef HAVE_MMAP

#include <sys/mman.h>

#endif

#include "glibconfig.h"

#ifdef G_OS_UNIX

#include <unistd.h>

#endif

#ifdef G_OS_WIN32

#include <windows.h>

#include <io.h>

#undef fstat

#define fstat(a,b) _fstati64(a,b)

#undef stat

#define stat _stati64

#ifndef S_ISREG

#define S_ISREG(m) (((m) & _S_IFMT) == _S_IFREG)

#endif

#endif

#include "gconvert.h"

#include "gerror.h"

#include "gfileutils.h"

#include "gmappedfile.h"

#include "gmem.h"

#include "gmessages.h"

#include "gstdio.h"

#include "gstrfuncs.h"

#include "gatomic.h"

#include "glibintl.h"

#ifndef _O_BINARY

#define _O_BINARY 0

#endif

#ifndef MAP_FAILED

#define MAP_FAILED ((void *) -1)

#endif

/**

 * GMappedFile:

 *

 * The #GMappedFile represents a file mapping created with

 * g_mapped_file_new(). It has only private members and should

 * not be accessed directly.

 */

struct _GMappedFile

{

  gchar *contents;

  gsize  length;

  gpointer free_func;

  int    ref_count;

#ifdef G_OS_WIN32

  HANDLE mapping;

#endif

};

static void

g_mapped_file_destroy (GMappedFile *file)

{

  if (file->length)

    {

#ifdef HAVE_MMAP

      munmap (file->contents, file->length);

#endif

#ifdef G_OS_WIN32

      UnmapViewOfFile (file->contents);

      CloseHandle (file->mapping);

#endif

    }

  g_slice_free (GMappedFile, file);

}

static GMappedFile*

mapped_file_new_from_fd (int           fd,

       gboolean      writable,

                         const gchar  *filename,

                         GError      **error)

{

  GMappedFile *file;

  struct stat st;

  file = g_slice_new0 (GMappedFile);

  file->ref_count = 1;

  file->free_func = g_mapped_file_destroy;

  if (fstat (fd, &st) == -1)

    {

      int save_errno = errno;

      gchar *display_filename = filename ? g_filename_display_name (filename) : NULL;

      g_set_error (error,

                   G_FILE_ERROR,

                   g_file_error_from_errno (save_errno),

                   _("Failed to get attributes of file “%s%s%s%s”: fstat() failed: %s"),

       display_filename ? display_filename : "fd",

       display_filename ? "' " : "",

       display_filename ? display_filename : "",

       display_filename ? "'" : "",

       g_strerror (save_errno));

      g_free (display_filename);

      goto out;

    }

  /* mmap() on size 0 will fail with EINVAL, so we avoid calling mmap()

   * in that case -- but only if we have a regular file; we still want

   * attempts to mmap a character device to fail, for example.

   */

  if (st.st_size == 0 && S_ISREG (st.st_mode))

    {

      file->length = 0;

      file->contents = NULL;

      return file;

    }

  file->contents = MAP_FAILED;

#ifdef HAVE_MMAP

  if (sizeof (st.st_size) > sizeof (gsize) && st.st_size > (off_t) G_MAXSIZE)

    {

      errno = EINVAL;

    }

  else

    {      

      file->length = (gsize) st.st_size;

      file->contents = (gchar *) mmap (NULL,  file->length,

               writable ? PROT_READ|PROT_WRITE : PROT_READ,

               MAP_PRIVATE, fd, 0);

    }

#endif

#ifdef G_OS_WIN32

  file->length = st.st_size;

  file->mapping = CreateFileMapping ((HANDLE) _get_osfhandle (fd), NULL,

             writable ? PAGE_WRITECOPY : PAGE_READONLY,

             0, 0,

             NULL);

  if (file->mapping != NULL)

    {

      file->contents = MapViewOfFile (file->mapping,

              writable ? FILE_MAP_COPY : FILE_MAP_READ,

              0, 0,

              0);

      if (file->contents == NULL)

  {

    file->contents = MAP_FAILED;

    CloseHandle (file->mapping);

    file->mapping = NULL;

  }

    }

#endif

  if (file->contents == MAP_FAILED)

    {

      int save_errno = errno;

      gchar *display_filename = filename ? g_filename_display_name (filename) : NULL;

      g_set_error (error,

       G_FILE_ERROR,

       g_file_error_from_errno (save_errno),

       _("Failed to map %s%s%s%s: mmap() failed: %s"),

       display_filename ? display_filename : "fd",

       display_filename ? "' " : "",

       display_filename ? display_filename : "",

       display_filename ? "'" : "",

       g_strerror (save_errno));

      g_free (display_filename);

      goto out;

    }

  return file;

 out:

  g_slice_free (GMappedFile, file);

  return NULL;

}

/**

 * g_mapped_file_new:

 * @filename: (type filename): The path of the file to load, in the GLib

 *     filename encoding

 * @writable: whether the mapping should be writable

 * @error: return location for a #GError, or %NULL

 *

 * Maps a file into memory. On UNIX, this is using the mmap() function.

 *

 * If @writable is %TRUE, the mapped buffer may be modified, otherwise

 * it is an error to modify the mapped buffer. Modifications to the buffer

 * are not visible to other processes mapping the same file, and are not

 * written back to the file.

 *

 * Note that modifications of the underlying file might affect the contents

 * of the #GMappedFile. Therefore, mapping should only be used if the file

 * will not be modified, or if all modifications of the file are done

 * atomically (e.g. using g_file_set_contents()).

 *

 * If @filename is the name of an empty, regular file, the function

 * will successfully return an empty #GMappedFile. In other cases of

 * size 0 (e.g. device files such as /dev/null), @error will be set

 * to the #GFileError value %G_FILE_ERROR_INVAL.

 *

 * Returns: a newly allocated #GMappedFile which must be unref'd

 *    with g_mapped_file_unref(), or %NULL if the mapping failed.

 *

 * Since: 2.8

 */

GMappedFile *

g_mapped_file_new (const gchar  *filename,

       gboolean      writable,

       GError      **error)

{

  GMappedFile *file;

  int fd;

  g_return_val_if_fail (filename != NULL, NULL);

  g_return_val_if_fail (!error || *error == NULL, NULL);

  fd = g_open (filename, (writable ? O_RDWR : O_RDONLY) | _O_BINARY, 0);

  if (fd == -1)

    {

      int save_errno = errno;

      gchar *display_filename = g_filename_display_name (filename);

      g_set_error (error,

                   G_FILE_ERROR,

                   g_file_error_from_errno (save_errno),

                   _("Failed to open file “%s”: open() failed: %s"),

                   display_filename,

       g_strerror (save_errno));

      g_free (display_filename);

      return NULL;

    }

  file = mapped_file_new_from_fd (fd, writable, filename, error);

  close (fd);

  return file;

}

/**

 * g_mapped_file_new_from_fd:

 * @fd: The file descriptor of the file to load

 * @writable: whether the mapping should be writable

 * @error: return location for a #GError, or %NULL

 *

 * Maps a file into memory. On UNIX, this is using the mmap() function.

 *

 * If @writable is %TRUE, the mapped buffer may be modified, otherwise

 * it is an error to modify the mapped buffer. Modifications to the buffer

 * are not visible to other processes mapping the same file, and are not

 * written back to the file.

 *

 * Note that modifications of the underlying file might affect the contents

 * of the #GMappedFile. Therefore, mapping should only be used if the file

 * will not be modified, or if all modifications of the file are done

 * atomically (e.g. using g_file_set_contents()).

 *

 * Returns: a newly allocated #GMappedFile which must be unref'd

 *    with g_mapped_file_unref(), or %NULL if the mapping failed.

 *

 * Since: 2.32

 */

GMappedFile *

g_mapped_file_new_from_fd (gint          fd,

         gboolean      writable,

         GError      **error)

{

  return mapped_file_new_from_fd (fd, writable, NULL, error);

}

/**

 * g_mapped_file_get_length:

 * @file: a #GMappedFile

 *

 * Returns the length of the contents of a #GMappedFile.

 *

 * Returns: the length of the contents of @file.

 *

 * Since: 2.8

 */

gsize

g_mapped_file_get_length (GMappedFile *file)

{

  g_return_val_if_fail (file != NULL, 0);

  return file->length;

}

/**

 * g_mapped_file_get_contents:

 * @file: a #GMappedFile

 *

 * Returns the contents of a #GMappedFile. 

 *

 * Note that the contents may not be zero-terminated,

 * even if the #GMappedFile is backed by a text file.

 *

 * If the file is empty then %NULL is returned.

 *

 * Returns: the contents of @file, or %NULL.

 *

 * Since: 2.8

 */

gchar *

g_mapped_file_get_contents (GMappedFile *file)

{

  g_return_val_if_fail (file != NULL, NULL);

  return file->contents;

}

/**

 * g_mapped_file_free:

 * @file: a #GMappedFile

 *

 * This call existed before #GMappedFile had refcounting and is currently

 * exactly the same as g_mapped_file_unref().

 *

 * Since: 2.8

 * Deprecated:2.22: Use g_mapped_file_unref() instead.

 */

void

g_mapped_file_free (GMappedFile *file)

{

  g_mapped_file_unref (file);

}

/**

 * g_mapped_file_ref:

 * @file: a #GMappedFile

 *

 * Increments the reference count of @file by one.  It is safe to call

 * this function from any thread.

 *

 * Returns: the passed in #GMappedFile.

 *

 * Since: 2.22

 **/

GMappedFile *

g_mapped_file_ref (GMappedFile *file)

{

  g_return_val_if_fail (file != NULL, NULL);

  g_atomic_int_inc (&file->ref_count);

  return file;

}

/**

 * g_mapped_file_unref:

 * @file: a #GMappedFile

 *

 * Decrements the reference count of @file by one.  If the reference count

 * drops to 0, unmaps the buffer of @file and frees it.

 *

 * It is safe to call this function from any thread.

 *

 * Since 2.22

 **/

void

g_mapped_file_unref (GMappedFile *file)

{

  g_return_if_fail (file != NULL);

  if (g_atomic_int_dec_and_test (&file->ref_count))

    g_mapped_file_destroy (file);

}

/**

 * g_mapped_file_get_bytes:

 * @file: a #GMappedFile

 *

 * Creates a new #GBytes which references the data mapped from @file.

 * The mapped contents of the file must not be modified after creating this

 * bytes object, because a #GBytes should be immutable.

 *

 * Returns: (transfer full): A newly allocated #GBytes referencing data

 *     from @file

 *

 * Since: 2.34

 **/

GBytes *

g_mapped_file_get_bytes (GMappedFile *file)

{

  g_return_val_if_fail (file != NULL, NULL);

  return g_bytes_new_with_free_func (file->contents,

             file->length,

             (GDestroyNotify) g_mapped_file_unref,

             g_mapped_file_ref (file));

}