text: /* GLIB - Library of useful routines for C programming
   * gmappedfile.c: Simplified wrapper around the mmap() function.
   *
   * Copyright 2005 Matthias Clasen
   *
   * 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 (st.st_size > 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));
  }
  