/* gfileutils.c - File utility functions

 *

 *  Copyright 2000 Red Hat, Inc.

 * Portions copyright (c) 2006-2009 Nokia Corporation.  All rights reserved.

 * GLib 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 of the

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

 *

 * GLib 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 GLib; see the file COPYING.LIB.  If not,

 * write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 *   Boston, MA 02111-1307, USA.

 */

#include "config.h"

#include "glib.h"

#include <sys/stat.h>

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#endif

#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_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 "gstdio.h"

#include "glibintl.h"

#include "galias.h"

#ifdef __SYMBIAN32__

#include "glib_wsd.h"

#endif /* __SYMBIAN32__ */

static gint create_temp_file (gchar *tmpl, 

			      int    permissions);

/**

 * g_mkdir_with_parents:

 * @pathname: 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

 */

EXPORT_C 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)

	    {

	      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: 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, <literal>(G_FILE_TEST_EXISTS | 

 * G_FILE_TEST_IS_DIR)</literal> 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.

 *

 * Return value: whether a test was %TRUE

 **/

EXPORT_C gboolean

g_file_test (const gchar *filename,

             GFileTest    test)

{

#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

  int attributes;

  wchar_t *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)

    return (attributes & (FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_DEVICE)) == 0;

  if (test & G_FILE_TEST_IS_DIR)

    return (attributes & FILE_ATTRIBUTE_DIRECTORY) != 0;

  if (test & G_FILE_TEST_IS_EXECUTABLE)

    {

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

      const gchar *pathext = NULL, *p;

      int extlen;

      if (lastdot == NULL)

	return FALSE;

      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)

	return FALSE;

      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);

      return FALSE;

    }

  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))

    {

      #ifndef __SYMBIAN32__

      if (getuid () != 0)

      #endif /* __SYMBIAN32__ */

	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

}

EXPORT_C GQuark

g_file_error_quark (void)

{

  return g_quark_from_static_string ("g-file-error-quark");

}

/**

 * g_file_error_from_errno:

 * @err_no: an "errno" value

 * 

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

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

 * 

 * Return value: #GFileError corresponding to the given @errno

 **/

EXPORT_C GFileError

g_file_error_from_errno (gint err_no)

{

  switch (err_no)

    {

#ifdef EEXIST

    case EEXIST:

      return G_FILE_ERROR_EXIST;

      break;

#endif

#ifdef EISDIR

    case EISDIR:

      return G_FILE_ERROR_ISDIR;

      break;

#endif

#ifdef EACCES

    case EACCES:

      return G_FILE_ERROR_ACCES;

      break;

#endif

#ifdef ENAMETOOLONG

    case ENAMETOOLONG:

      return G_FILE_ERROR_NAMETOOLONG;

      break;

#endif

#ifdef ENOENT

    case ENOENT:

      return G_FILE_ERROR_NOENT;

      break;

#endif

#ifdef ENOTDIR

    case ENOTDIR:

      return G_FILE_ERROR_NOTDIR;

      break;

#endif

#ifdef ENXIO

    case ENXIO:

      return G_FILE_ERROR_NXIO;

      break;

#endif

#ifdef ENODEV

    case ENODEV:

      return G_FILE_ERROR_NODEV;

      break;

#endif

#ifdef EROFS

    case EROFS:

      return G_FILE_ERROR_ROFS;

      break;

#endif

#ifdef ETXTBSY

    case ETXTBSY:

      return G_FILE_ERROR_TXTBSY;

      break;

#endif

#ifdef EFAULT

    case EFAULT:

      return G_FILE_ERROR_FAULT;

      break;

#endif

#ifdef ELOOP

    case ELOOP:

      return G_FILE_ERROR_LOOP;

      break;

#endif

#ifdef ENOSPC

    case ENOSPC:

      return G_FILE_ERROR_NOSPC;

      break;

#endif

#ifdef ENOMEM

    case ENOMEM:

      return G_FILE_ERROR_NOMEM;

      break;

#endif

#ifdef EMFILE

    case EMFILE:

      return G_FILE_ERROR_MFILE;

      break;

#endif

#ifdef ENFILE

    case ENFILE:

      return G_FILE_ERROR_NFILE;

      break;

#endif

#ifdef EBADF

    case EBADF:

      return G_FILE_ERROR_BADF;

      break;

#endif

#ifdef EINVAL

    case EINVAL:

      return G_FILE_ERROR_INVAL;

      break;

#endif

#ifdef EPIPE

    case EPIPE:

      return G_FILE_ERROR_PIPE;

      break;

#endif

#ifdef EAGAIN

    case EAGAIN:

      return G_FILE_ERROR_AGAIN;

      break;

#endif

#ifdef EINTR

    case EINTR:

      return G_FILE_ERROR_INTR;

      break;

#endif

#ifdef EIO

    case EIO:

      return G_FILE_ERROR_IO;

      break;

#endif

#ifdef EPERM

    case EPERM:

      return G_FILE_ERROR_PERM;

      break;

#endif

#ifdef ENOSYS

    case ENOSYS:

      return G_FILE_ERROR_NOSYS;

      break;

#endif

    default:

      return G_FILE_ERROR_FAILED;

      break;

    }

}

static gboolean

get_contents_stdio (const gchar  *display_filename,

                    FILE         *f,

                    gchar       **contents,

                    gsize        *length,

                    GError      **error)

{

  gchar buf[4096];

  gsize bytes;

  gchar *str = NULL;

  gsize total_bytes = 0;

  gsize total_allocated = 0;

  gchar *tmp;

  g_assert (f != NULL);

  while (!feof (f))

    {

      gint save_errno;

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

      save_errno = errno;

      while ((total_bytes + bytes + 1) > total_allocated)

        {

          if (str)

            total_allocated *= 2;

          else