1 /* gfileutils.c - File utility functions

     2  *

     3  *  Copyright 2000 Red Hat, Inc.

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

     5  *

     6  * GLib is free software; you can redistribute it and/or modify it

     7  * under the terms of the GNU Lesser General Public License as

     8  * published by the Free Software Foundation; either version 2 of the

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

    10  *

    11  * GLib is distributed in the hope that it will be useful,

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

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

    14  * Lesser General Public License for more details.

    15  *

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

    17  * License along with GLib; see the file COPYING.LIB.  If not,

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

    19  *   Boston, MA 02111-1307, USA.

    20  */

    21 

    22 #include "config.h"

    23 

    24 #include "glib.h"

    25 

    26 #include <sys/stat.h>

    27 #ifdef HAVE_UNISTD_H

    28 #include <unistd.h>

    29 #endif

    30 #include <stdio.h>

    31 #include <stdlib.h>

    32 #include <stdarg.h>

    33 #include <string.h>

    34 #include <errno.h>

    35 #include <sys/types.h>

    36 #include <sys/stat.h>

    37 #include <fcntl.h>

    38 #include <stdlib.h>

    39 

    40 #ifdef G_OS_WIN32

    41 #include <windows.h>

    42 #include <io.h>

    43 #endif /* G_OS_WIN32 */

    44 

    45 #ifndef S_ISLNK

    46 #define S_ISLNK(x) 0

    47 #endif

    48 

    49 #ifndef O_BINARY

    50 #define O_BINARY 0

    51 #endif

    52 

    53 #include "gstdio.h"

    54 #include "glibintl.h"

    55 

    56 #include "galias.h"

    57 

    58 #ifdef __SYMBIAN32__

    59 #include <glib_wsd.h>

    60 #endif /* __SYMBIAN32__ */

    61 

    62 

    63 /**

    64  * g_mkdir_with_parents:

    65  * @pathname: a pathname in the GLib file name encoding

    66  * @mode: permissions to use for newly created directories

    67  *

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

    69  * parent directories as needed, too.

    70  *

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

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

    73  *

    74  * Since: 2.8

    75  */

    76 EXPORT_C int

    77 g_mkdir_with_parents (const gchar *pathname,

    78 		      int          mode)

    79 {

    80   gchar *fn, *p;

    81 

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

    83     {

    84       errno = EINVAL;

    85       return -1;

    86     }

    87 

    88   fn = g_strdup (pathname);

    89 

    90   if (g_path_is_absolute (fn))

    91     p = (gchar *) g_path_skip_root (fn);

    92   else

    93     p = fn;

    94 

    95   do

    96     {

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

    98 	p++;

    99       

   100       if (!*p)

   101 	p = NULL;

   102       else

   103 	*p = '\0';

   104       

   105       if (!g_file_test (fn, G_FILE_TEST_EXISTS))

   106 	{

   107 	  if (g_mkdir (fn, mode) == -1)

   108 	    {

   109 	      int errno_save = errno;

   110 	      g_free (fn);

   111 	      errno = errno_save;

   112 	      return -1;

   113 	    }

   114 	}

   115       else if (!g_file_test (fn, G_FILE_TEST_IS_DIR))

   116 	{

   117 	  g_free (fn);

   118 	  errno = ENOTDIR;

   119 	  return -1;

   120 	}

   121       if (p)

   122 	{

   123 	  *p++ = G_DIR_SEPARATOR;

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

   125 	    p++;

   126 	}

   127     }

   128   while (p);

   129 

   130   g_free (fn);

   131 

   132   return 0;

   133 }

   134 

   135 /**

   136  * g_file_test:

   137  * @filename: a filename to test in the GLib file name encoding

   138  * @test: bitfield of #GFileTest flags

   139  * 

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

   141  * %TRUE. For example, <literal>(G_FILE_TEST_EXISTS | 

   142  * G_FILE_TEST_IS_DIR)</literal> will return %TRUE if the file exists; 

   143  * the check whether it's a directory doesn't matter since the existence 

   144  * test is %TRUE. With the current set of available tests, there's no point

   145  * passing in more than one test at a time.

   146  * 

   147  * Apart from %G_FILE_TEST_IS_SYMLINK all tests follow symbolic links,

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

   149  * %TRUE for both %G_FILE_TEST_IS_SYMLINK and %G_FILE_TEST_IS_REGULAR.

   150  *

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

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

   153  *

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

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

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

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

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

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

   160  *

   161  * <informalexample><programlisting>

   162  * /* DON'T DO THIS */

   163  *  if (!g_file_test (filename, G_FILE_TEST_IS_SYMLINK)) {

   164  *    fd = g_open (filename, O_WRONLY);

   165  *    /* write to fd */

   166  *  }

   167  * </programlisting></informalexample>

   168  *

   169  * Another thing to note is that %G_FILE_TEST_EXISTS and

   170  * %G_FILE_TEST_IS_EXECUTABLE are implemented using the access()

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

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

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

   174  * effective user ID and group ID.

   175  *

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

   177  * %G_FILE_TEST_IS_SYMLINK will always return %FALSE. Testing for

   178  * %G_FILE_TEST_IS_EXECUTABLE will just check that the file exists and

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

   180  * extensions and those listed in the %PATHEXT environment variable.

   181  *

   182  * Return value: whether a test was %TRUE

   183  **/

   184 EXPORT_C gboolean

   185 g_file_test (const gchar *filename,

   186              GFileTest    test)

   187 {

   188 #ifdef G_OS_WIN32

   189 /* stuff missing in std vc6 api */

   190 #  ifndef INVALID_FILE_ATTRIBUTES

   191 #    define INVALID_FILE_ATTRIBUTES -1

   192 #  endif

   193 #  ifndef FILE_ATTRIBUTE_DEVICE

   194 #    define FILE_ATTRIBUTE_DEVICE 64

   195 #  endif

   196   int attributes;

   197 

   198   if (G_WIN32_HAVE_WIDECHAR_API ())

   199     {

   200       wchar_t *wfilename = g_utf8_to_utf16 (filename, -1, NULL, NULL, NULL);

   201 

   202       if (wfilename == NULL)

   203 	return FALSE;

   204 

   205       attributes = GetFileAttributesW (wfilename);

   206 

   207       g_free (wfilename);

   208     }

   209   else

   210     {

   211       gchar *cpfilename = g_locale_from_utf8 (filename, -1, NULL, NULL, NULL);

   212 

   213       if (cpfilename == NULL)

   214 	return FALSE;

   215       

   216       attributes = GetFileAttributesA (cpfilename);

   217       

   218       g_free (cpfilename);

   219     }

   220 

   221   if (attributes == INVALID_FILE_ATTRIBUTES)

   222     return FALSE;

   223 

   224   if (test & G_FILE_TEST_EXISTS)

   225     return TRUE;

   226       

   227   if (test & G_FILE_TEST_IS_REGULAR)

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

   229 

   230   if (test & G_FILE_TEST_IS_DIR)

   231     return (attributes & FILE_ATTRIBUTE_DIRECTORY) != 0;

   232 

   233   if (test & G_FILE_TEST_IS_EXECUTABLE)

   234     {

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

   236       const gchar *pathext = NULL, *p;

   237       int extlen;

   238 

   239       if (lastdot == NULL)

   240 	return FALSE;

   241 

   242       if (stricmp (lastdot, ".exe") == 0 ||

   243 	  stricmp (lastdot, ".cmd") == 0 ||

   244 	  stricmp (lastdot, ".bat") == 0 ||

   245 	  stricmp (lastdot, ".com") == 0)

   246 	return TRUE;

   247 

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

   249 

   250       pathext = g_getenv ("PATHEXT");

   251       if (pathext == NULL)

   252 	return FALSE;

   253 

   254       pathext = g_utf8_casefold (pathext, -1);

   255 

   256       lastdot = g_utf8_casefold (lastdot, -1);

   257       extlen = strlen (lastdot);

   258 

   259       p = pathext;

   260       while (TRUE)

   261 	{

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

   263 	  if (q == NULL)

   264 	    q = p + strlen (p);

   265 	  if (extlen == q - p &&

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

   267 	    {

   268 	      g_free ((gchar *) pathext);

   269 	      g_free ((gchar *) lastdot);

   270 	      return TRUE;

   271 	    }

   272 	  if (*q)

   273 	    p = q + 1;

   274 	  else

   275 	    break;

   276 	}

   277 

   278       g_free ((gchar *) pathext);

   279       g_free ((gchar *) lastdot);

   280       return FALSE;

   281     }

   282 

   283   return FALSE;

   284 #else

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

   286     return TRUE;

   287   

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

   289     {

   290       #ifndef __SYMBIAN32__

   291       if (getuid () != 0)

   292       #endif /* __SYMBIAN32__ */

   293 		return TRUE;

   294 

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

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

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

   298        */

   299     }

   300   else

   301     test &= ~G_FILE_TEST_IS_EXECUTABLE;

   302 

   303   if (test & G_FILE_TEST_IS_SYMLINK)

   304     {

   305       struct stat s;

   306 

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

   308         return TRUE;

   309     }

   310   

   311   if (test & (G_FILE_TEST_IS_REGULAR |

   312 	      G_FILE_TEST_IS_DIR |

   313 	      G_FILE_TEST_IS_EXECUTABLE))

   314     {

   315       struct stat s;

   316       

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

   318 	{

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

   320 	    return TRUE;

   321 	  

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

   323 	    return TRUE;

   324 

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

   326 	   */

   327 	  if ((test & G_FILE_TEST_IS_EXECUTABLE) &&

   328 	      ((s.st_mode & S_IXOTH) ||

   329 	       (s.st_mode & S_IXUSR) ||

   330 	       (s.st_mode & S_IXGRP)))

   331 	    return TRUE;

   332 	}

   333     }

   334 

   335   return FALSE;

   336 #endif

   337 }

   338 

   339 #ifdef G_OS_WIN32

   340 

   341 #undef g_file_test

   342 

   343 /* Binary compatibility version. Not for newly compiled code. */

   344 

   345 EXPORT_C gboolean

   346 g_file_test (const gchar *filename,

   347              GFileTest    test)

   348 {

   349   gchar *utf8_filename = g_locale_to_utf8 (filename, -1, NULL, NULL, NULL);

   350   gboolean retval;

   351 

   352   if (utf8_filename == NULL)

   353     return FALSE;

   354 

   355   retval = g_file_test_utf8 (utf8_filename, test);

   356 

   357   g_free (utf8_filename);

   358 

   359   return retval;

   360 }

   361 

   362 #endif

   363 

   364 #if EMULATOR

   365 

   366 PLS(q,g_file_error_quark ,GQuark)

   367 #define q (*FUNCTION_NAME(q,g_file_error_quark )())

   368 

   369 #endif /* EMULATOR */

   370 

   371 EXPORT_C GQuark

   372 g_file_error_quark (void)

   373 {

   374   #if !(EMULATOR)

   375   static GQuark q = 0;

   376   #endif /* EMULATOR */

   377   

   378   if (q == 0)

   379     q = g_quark_from_static_string ("g-file-error-quark");

   380 

   381   return q;

   382 }

   383 #if EMULATOR

   384 #undef q

   385 #endif /* EMULATOR */

   386 

   387 /**

   388  * g_file_error_from_errno:

   389  * @err_no: an "errno" value

   390  * 

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

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

   393  * #G_FILE_ERROR_EXIST. Unlike @errno values, you can portably

   394  * assume that all #GFileError values will exist.

   395  *

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

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

   398  * g_file_error_from_errno() when constructing a #GError.

   399  * 

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

   401  **/

   402 EXPORT_C GFileError

   403 g_file_error_from_errno (gint err_no)

   404 {

   405   switch (err_no)

   406     {

   407 #ifdef EEXIST

   408     case EEXIST:

   409       return G_FILE_ERROR_EXIST;

   410       break;

   411 #endif

   412 

   413 #ifdef EISDIR

   414     case EISDIR:

   415       return G_FILE_ERROR_ISDIR;

   416       break;

   417 #endif

   418 

   419 #ifdef EACCES

   420     case EACCES:

   421       return G_FILE_ERROR_ACCES;

   422       break;

   423 #endif

   424 

   425 #ifdef ENAMETOOLONG

   426     case ENAMETOOLONG:

   427       return G_FILE_ERROR_NAMETOOLONG;

   428       break;

   429 #endif

   430 

   431 #ifdef ENOENT

   432     case ENOENT:

   433       return G_FILE_ERROR_NOENT;

   434       break;

   435 #endif

   436 

   437 #ifdef ENOTDIR

   438     case ENOTDIR:

   439       return G_FILE_ERROR_NOTDIR;

   440       break;

   441 #endif

   442 

   443 #ifdef ENXIO

   444     case ENXIO:

   445       return G_FILE_ERROR_NXIO;

   446       break;

   447 #endif

   448 

   449 #ifdef ENODEV

   450     case ENODEV:

   451       return G_FILE_ERROR_NODEV;

   452       break;

   453 #endif

   454 

   455 #ifdef EROFS

   456     case EROFS:

   457       return G_FILE_ERROR_ROFS;

   458       break;

   459 #endif

   460 

   461 #ifdef ETXTBSY

   462     case ETXTBSY:

   463       return G_FILE_ERROR_TXTBSY;

   464       break;

   465 #endif

   466 

   467 #ifdef EFAULT

   468     case EFAULT:

   469       return G_FILE_ERROR_FAULT;

   470       break;

   471 #endif

   472 

   473 #ifdef ELOOP

   474     case ELOOP:

   475       return G_FILE_ERROR_LOOP;

   476       break;

   477 #endif

   478 

   479 #ifdef ENOSPC

   480     case ENOSPC:

   481       return G_FILE_ERROR_NOSPC;

   482       break;

   483 #endif

   484 

   485 #ifdef ENOMEM

   486     case ENOMEM:

   487       return G_FILE_ERROR_NOMEM;

   488       break;

   489 #endif

   490 

   491 #ifdef EMFILE

   492     case EMFILE:

   493       return G_FILE_ERROR_MFILE;

   494       break;

   495 #endif

   496 

   497 #ifdef ENFILE

   498     case ENFILE:

   499       return G_FILE_ERROR_NFILE;

   500       break;

   501 #endif

   502 

   503 #ifdef EBADF

   504     case EBADF:

   505       return G_FILE_ERROR_BADF;

   506       break;

   507 #endif

   508 

   509 #ifdef EINVAL

   510     case EINVAL:

   511       return G_FILE_ERROR_INVAL;

   512       break;

   513 #endif

   514 

   515 #ifdef EPIPE

   516     case EPIPE:

   517       return G_FILE_ERROR_PIPE;

   518       break;

   519 #endif

   520 

   521 #ifdef EAGAIN

   522     case EAGAIN:

   523       return G_FILE_ERROR_AGAIN;

   524       break;

   525 #endif

   526 

   527 #ifdef EINTR

   528     case EINTR:

   529       return G_FILE_ERROR_INTR;

   530       break;

   531 #endif

   532 

   533 #ifdef EIO

   534     case EIO:

   535       return G_FILE_ERROR_IO;

   536       break;

   537 #endif

   538 

   539 #ifdef EPERM

   540     case EPERM:

   541       return G_FILE_ERROR_PERM;

   542       break;

   543 #endif

   544 

   545 #ifdef ENOSYS

   546     case ENOSYS:

   547       return G_FILE_ERROR_NOSYS;

   548       break;

   549 #endif

   550 

   551     default:

   552       return G_FILE_ERROR_FAILED;

   553       break;

   554     }

   555 }

   556 

   557 static gboolean

   558 get_contents_stdio (const gchar *display_filename,

   559                     FILE        *f,

   560                     gchar      **contents,

   561                     gsize       *length,

   562                     GError     **error)

   563 {

   564   gchar buf[4096];

   565   size_t bytes;

   566   gchar *str = NULL;

   567   size_t total_bytes = 0;

   568   size_t total_allocated = 0;

   569   gchar *tmp;

   570 

   571   g_assert (f != NULL);

   572 

   573   while (!feof (f))

   574     {

   575       gint save_errno;

   576 

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

   578       save_errno = errno;

   579 

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

   581         {

   582           if (str)

   583             total_allocated *= 2;

   584           else

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

   586 

   587           tmp = g_try_realloc (str, total_allocated);

   588 

   589           if (tmp == NULL)

   590             {

   591               g_set_error (error,

   592                            G_FILE_ERROR,

   593                            G_FILE_ERROR_NOMEM,

   594                            _("Could not allocate %lu bytes to read file \"%s\""),

   595                            (gulong) total_allocated,

   596 			   display_filename);

   597 

   598               goto error;

   599             }

   600 

   601 	  str = tmp;

   602         }

   603 

   604       if (ferror (f))

   605         {

   606           g_set_error (error,

   607                        G_FILE_ERROR,

   608                        g_file_error_from_errno (save_errno),

   609                        _("Error reading file '%s': %s"),

   610                        display_filename,

   611 		       g_strerror (save_errno));

   612 

   613           goto error;

   614         }

   615 

   616       memcpy (str + total_bytes, buf, bytes);

   617       total_bytes += bytes;

   618     }

   619 

   620   fclose (f);

   621 

   622   if (total_allocated == 0)

   623     str = g_new (gchar, 1);

   624 

   625   str[total_bytes] = '\0';

   626 

   627   if (length)

   628     *length = total_bytes;

   629 

   630   *contents = str;

   631 

   632   return TRUE;

   633 

   634  error:

   635 

   636   g_free (str);

   637   fclose (f);

   638 

   639   return FALSE;

   640 }

   641 

   642 #ifndef G_OS_WIN32

   643 

   644 static gboolean

   645 get_contents_regfile (const gchar *display_filename,

   646                       struct stat *stat_buf,

   647                       gint         fd,

   648                       gchar      **contents,

   649                       gsize       *length,

   650                       GError     **error)

   651 {

   652   gchar *buf;

   653   size_t bytes_read;

   654   size_t size;

   655   size_t alloc_size;

   656   

   657   size = stat_buf->st_size;

   658 

   659   alloc_size = size + 1;

   660   buf = g_try_malloc (alloc_size);

   661 

   662   if (buf == NULL)

   663     {

   664       g_set_error (error,

   665                    G_FILE_ERROR,

   666                    G_FILE_ERROR_NOMEM,

   667                    _("Could not allocate %lu bytes to read file \"%s\""),

   668                    (gulong) alloc_size, 

   669 		   display_filename);

   670 

   671       goto error;

   672     }

   673   

   674   bytes_read = 0;

   675   while (bytes_read < size)

   676     {

   677       gssize rc;

   678           

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

   680 

   681       if (rc < 0)

   682         {

   683           if (errno != EINTR) 

   684             {

   685 	      int save_errno = errno;

   686 

   687               g_free (buf);

   688               g_set_error (error,

   689                            G_FILE_ERROR,

   690                            g_file_error_from_errno (save_errno),

   691                            _("Failed to read from file '%s': %s"),

   692                            display_filename, 

   693 			   g_strerror (save_errno));

   694 

   695 	      goto error;

   696             }

   697         }

   698       else if (rc == 0)

   699         break;

   700       else

   701         bytes_read += rc;

   702     }

   703       

   704   buf[bytes_read] = '\0';

   705 

   706   if (length)

   707     *length = bytes_read;

   708   

   709   *contents = buf;

   710 

   711   close (fd);

   712 

   713   return TRUE;

   714 

   715  error:

   716 

   717   close (fd);

   718   

   719   return FALSE;

   720 }

   721 

   722 static gboolean

   723 get_contents_posix (const gchar *filename,

   724                     gchar      **contents,

   725                     gsize       *length,

   726                     GError     **error)

   727 {

   728   struct stat stat_buf;

   729   gint fd;

   730   gchar *display_filename = g_filename_display_name (filename);

   731 

   732   /* O_BINARY useful on Cygwin */

   733   fd = open (filename, O_RDONLY|O_BINARY);

   734 

   735   if (fd < 0)

   736     {

   737       int save_errno = errno;

   738 

   739       g_set_error (error,

   740                    G_FILE_ERROR,

   741                    g_file_error_from_errno (save_errno),

   742                    _("Failed to open file '%s': %s"),

   743                    display_filename, 

   744 		   g_strerror (save_errno));

   745       g_free (display_filename);

   746 

   747       return FALSE;

   748     }

   749 

   750   /* I don't think this will ever fail, aside from ENOMEM, but. */

   751   if (fstat (fd, &stat_buf) < 0)

   752     {

   753       int save_errno = errno;

   754 

   755       close (fd);

   756       g_set_error (error,

   757                    G_FILE_ERROR,

   758                    g_file_error_from_errno (save_errno),

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

   760                    display_filename, 

   761 		   g_strerror (save_errno));

   762       g_free (display_filename);

   763 

   764       return FALSE;

   765     }

   766 

   767   if (stat_buf.st_size > 0 && S_ISREG (stat_buf.st_mode))

   768     {

   769       gboolean retval = get_contents_regfile (display_filename,

   770 					      &stat_buf,

   771 					      fd,

   772 					      contents,

   773 					      length,

   774 					      error);

   775       g_free (display_filename);

   776 

   777       return retval;

   778     }

   779   else

   780     {

   781       FILE *f;

   782       gboolean retval;

   783 

   784       f = fdopen (fd, "r");

   785       

   786       if (f == NULL)

   787         {

   788 	  int save_errno = errno;

   789 

   790           g_set_error (error,

   791                        G_FILE_ERROR,

   792                        g_file_error_from_errno (save_errno),

   793                        _("Failed to open file '%s': fdopen() failed: %s"),

   794                        display_filename, 

   795 		       g_strerror (save_errno));

   796           g_free (display_filename);

   797 

   798           return FALSE;

   799         }

   800   

   801       retval = get_contents_stdio (display_filename, f, contents, length, error);

   802       g_free (display_filename);

   803 

   804       return retval;

   805     }

   806 }

   807 

   808 #else  /* G_OS_WIN32 */

   809 

   810 static gboolean

   811 get_contents_win32 (const gchar *filename,

   812 		    gchar      **contents,

   813 		    gsize       *length,

   814 		    GError     **error)

   815 {

   816   FILE *f;

   817   gboolean retval;

   818   gchar *display_filename = g_filename_display_name (filename);

   819   int save_errno;

   820   

   821   f = g_fopen (filename, "rb");

   822   save_errno = errno;

   823 

   824   if (f == NULL)

   825     {

   826       g_set_error (error,

   827                    G_FILE_ERROR,

   828                    g_file_error_from_errno (save_errno),

   829                    _("Failed to open file '%s': %s"),

   830                    display_filename,

   831 		   g_strerror (save_errno));

   832       g_free (display_filename);

   833 

   834       return FALSE;

   835     }

   836   

   837   retval = get_contents_stdio (display_filename, f, contents, length, error);

   838   g_free (display_filename);

   839 

   840   return retval;

   841 }

   842 

   843 #endif

   844 

   845 /**

   846  * g_file_get_contents:

   847  * @filename: name of a file to read contents from, in the GLib file name encoding

   848  * @contents: location to store an allocated string

   849  * @length: location to store length in bytes of the contents, or %NULL

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

   851  * 

   852  * Reads an entire file into allocated memory, with good error

   853  * checking. 

   854  *

   855  * If the call was successful, it returns %TRUE and sets @contents to the file 

   856  * contents and @length to the length of the file contents in bytes. The string 

   857  * stored in @contents will be nul-terminated, so for text files you can pass 

   858  * %NULL for the @length argument. If the call was not successful, it returns 

   859  * %FALSE and sets @error. The error domain is #G_FILE_ERROR. Possible error  

   860  * codes are those in the #GFileError enumeration. In the error case, 

   861  * @contents is set to %NULL and @length is set to zero.

   862  *

   863  * Return value: %TRUE on success, %FALSE if an error occurred

   864  **/

   865 EXPORT_C gboolean

   866 g_file_get_contents (const gchar *filename,

   867                      gchar      **contents,

   868                      gsize       *length,

   869                      GError     **error)

   870 {  

   871   g_return_val_if_fail (filename != NULL, FALSE);

   872   g_return_val_if_fail (contents != NULL, FALSE);

   873 

   874   *contents = NULL;

   875   if (length)

   876     *length = 0;

   877 

   878 #ifdef G_OS_WIN32

   879   return get_contents_win32 (filename, contents, length, error);

   880 #else

   881   return get_contents_posix (filename, contents, length, error);

   882 #endif

   883 }

   884 

   885 #ifdef G_OS_WIN32

   886 

   887 #undef g_file_get_contents

   888 

   889 /* Binary compatibility version. Not for newly compiled code. */

   890 

   891 gboolean

   892 g_file_get_contents (const gchar *filename,

   893                      gchar      **contents,

   894                      gsize       *length,

   895                      GError     **error)

   896 {

   897   gchar *utf8_filename = g_locale_to_utf8 (filename, -1, NULL, NULL, error);

   898   gboolean retval;

   899 

   900   if (utf8_filename == NULL)

   901     return FALSE;

   902 

   903   retval = g_file_get_contents_utf8 (utf8_filename, contents, length, error);

   904 

   905   g_free (utf8_filename);

   906 

   907   return retval;

   908 }

   909 

   910 #endif

   911 

   912 static gboolean

   913 rename_file (const char *old_name,

   914 	     const char *new_name,

   915 	     GError **err)

   916 {

   917   errno = 0;

   918   if (g_rename (old_name, new_name) == -1)

   919     {

   920       int save_errno = errno;

   921       gchar *display_old_name = g_filename_display_name (old_name);

   922       gchar *display_new_name = g_filename_display_name (new_name);

   923 

   924       g_set_error (err,

   925 		   G_FILE_ERROR,

   926 		   g_file_error_from_errno (save_errno),

   927 		   _("Failed to rename file '%s' to '%s': g_rename() failed: %s"),

   928 		   display_old_name,

   929 		   display_new_name,

   930 		   g_strerror (save_errno));

   931 

   932       g_free (display_old_name);

   933       g_free (display_new_name);

   934       

   935       return FALSE;

   936     }

   937   

   938   return TRUE;

   939 }

   940 

   941 static gchar *

   942 write_to_temp_file (const gchar *contents,

   943 		    gssize length,

   944 		    const gchar *template,

   945 		    GError **err)

   946 {

   947   gchar *tmp_name;

   948   gchar *display_name;

   949   gchar *retval;

   950   FILE *file;

   951   gint fd;

   952   int save_errno;

   953 

   954   retval = NULL;

   955   

   956   tmp_name = g_strdup_printf ("%s.XXXXXX", template);

   957 

   958   errno = 0;

   959   fd = create_temp_file (tmp_name, 0666);

   960   display_name = g_filename_display_name (tmp_name);

   961       

   962   if (fd == -1)

   963     {

   964       save_errno = errno;

   965       g_set_error (err,

   966 		   G_FILE_ERROR,

   967 		   g_file_error_from_errno (save_errno),

   968 		   _("Failed to create file '%s': %s"),

   969 		   display_name, g_strerror (save_errno));

   970       

   971       goto out;

   972     }

   973 

   974   errno = 0;

   975   file = fdopen (fd, "wb");

   976   if (!file)

   977     {

   978       save_errno = errno;

   979       g_set_error (err,

   980 		   G_FILE_ERROR,

   981 		   g_file_error_from_errno (save_errno),

   982 		   _("Failed to open file '%s' for writing: fdopen() failed: %s"),

   983 		   display_name,

   984 		   g_strerror (save_errno));

   985 

   986       close (fd);

   987       g_unlink (tmp_name);

   988       

   989       goto out;

   990     }

   991 

   992   if (length > 0)

   993     {

   994       size_t n_written;

   995       

   996       errno = 0;

   997 

   998       n_written = fwrite (contents, 1, length, file);

   999 

  1000       if (n_written < length)

  1001 	{

  1002 	  save_errno = errno;

  1003       

  1004  	  g_set_error (err,

  1005 		       G_FILE_ERROR,

  1006 		       g_file_error_from_errno (save_errno),

  1007 		       _("Failed to write file '%s': fwrite() failed: %s"),

  1008 		       display_name,

  1009 		       g_strerror (save_errno));

  1010 

  1011 	  fclose (file);

  1012 	  g_unlink (tmp_name);

  1013 	  

  1014 	  goto out;

  1015 	}

  1016     }

  1017    

  1018   errno = 0;

  1019   if (fclose (file) == EOF)

  1020     { 

  1021       save_errno = 0;

  1022       

  1023       g_set_error (err,

  1024 		   G_FILE_ERROR,

  1025 		   g_file_error_from_errno (save_errno),

  1026 		   _("Failed to close file '%s': fclose() failed: %s"),

  1027 		   display_name, 

  1028 		   g_strerror (save_errno));

  1029 

  1030       g_unlink (tmp_name);

  1031       

  1032       goto out;

  1033     }

  1034 

  1035   retval = g_strdup (tmp_name);

  1036   

  1037  out:

  1038   g_free (tmp_name);

  1039   g_free (display_name);

  1040   

  1041   return retval;

  1042 }

  1043 

  1044 /**

  1045  * g_file_set_contents:

  1046  * @filename: name of a file to write @contents to, in the GLib file name

  1047  *   encoding

  1048  * @contents: string to write to the file

  1049  * @length: length of @contents, or -1 if @contents is a nul-terminated string

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

  1051  *

  1052  * Writes all of @contents to a file named @filename, with good error checking.

  1053  * If a file called @filename already exists it will be overwritten.

  1054  *

  1055  * This write is atomic in the sense that it is first written to a temporary

  1056  * file which is then renamed to the final name. Notes:

  1057  * <itemizedlist>

  1058  * <listitem>

  1059  *    On Unix, if @filename already exists hard links to @filename will break.

  1060  *    Also since the file is recreated, existing permissions, access control

  1061  *    lists, metadata etc. may be lost. If @filename is a symbolic link,

  1062  *    the link itself will be replaced, not the linked file.

  1063  * </listitem>

  1064  * <listitem>

  1065  *   On Windows renaming a file will not remove an existing file with the

  1066  *   new name, so on Windows there is a race condition between the existing

  1067  *   file being removed and the temporary file being renamed.

  1068  * </listitem>

  1069  * <listitem>

  1070  *   On Windows there is no way to remove a file that is open to some

  1071  *   process, or mapped into memory. Thus, this function will fail if

  1072  *   @filename already exists and is open.

  1073  * </listitem>

  1074  * </itemizedlist>

  1075  *

  1076  * If the call was sucessful, it returns %TRUE. If the call was not successful,

  1077  * it returns %FALSE and sets @error. The error domain is #G_FILE_ERROR.

  1078  * Possible error codes are those in the #GFileError enumeration.

  1079  *

  1080  * Return value: %TRUE on success, %FALSE if an error occurred

  1081  *

  1082  * Since: 2.8

  1083  **/

  1084 EXPORT_C gboolean

  1085 g_file_set_contents (const gchar *filename,

  1086 		     const gchar *contents,

  1087 		     gssize	     length,

  1088 		     GError	   **error)

  1089 {

  1090   gchar *tmp_filename;

  1091   gboolean retval;

  1092   GError *rename_error = NULL;

  1093   

  1094   g_return_val_if_fail (filename != NULL, FALSE);

  1095   g_return_val_if_fail (error == NULL || *error == NULL, FALSE);

  1096   g_return_val_if_fail (contents != NULL || length == 0, FALSE);

  1097   g_return_val_if_fail (length >= -1, FALSE);

  1098   

  1099   if (length == -1)

  1100     length = strlen (contents);

  1101 

  1102   tmp_filename = write_to_temp_file (contents, length, filename, error);

  1103   

  1104   if (!tmp_filename)

  1105     {

  1106       retval = FALSE;

  1107       goto out;

  1108     }

  1109 

  1110   if (!rename_file (tmp_filename, filename, &rename_error))

  1111     {

  1112 #ifndef G_OS_WIN32

  1113 

  1114       g_unlink (tmp_filename);

  1115       g_propagate_error (error, rename_error);

  1116       retval = FALSE;

  1117       goto out;

  1118 

  1119 #else /* G_OS_WIN32 */

  1120       

  1121       /* Renaming failed, but on Windows this may just mean

  1122        * the file already exists. So if the target file

  1123        * exists, try deleting it and do the rename again.

  1124        */

  1125       if (!g_file_test (filename, G_FILE_TEST_EXISTS))

  1126 	{

  1127 	  g_unlink (tmp_filename);

  1128 	  g_propagate_error (error, rename_error);

  1129 	  retval = FALSE;

  1130 	  goto out;

  1131 	}

  1132 

  1133       g_error_free (rename_error);