glib/gfileutils.c

   1 /* gfileutils.c - File utility functions
   2  *
   3  *  Copyright 2000 Red Hat, Inc.
   4  *
   5  * GLib is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU Lesser General Public License as
   7  * published by the Free Software Foundation; either version 2 of the
   8  * License, or (at your option) any later version.
   9  *
  10  * GLib is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with GLib; see the file COPYING.LIB.  If not,
  17  * write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  *   Boston, MA 02111-1307, USA.
  19  */
  20
  21 #include "config.h"
  22
  23 #include "glib.h"
  24
  25 #include <sys/stat.h>
  26 #ifdef HAVE_UNISTD_H
  27 #include <unistd.h>
  28 #endif
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <stdarg.h>
  32 #include <string.h>
  33 #include <errno.h>
  34 #include <sys/types.h>
  35 #include <sys/stat.h>
  36 #include <fcntl.h>
  37 #include <stdlib.h>
  38
  39 #ifdef G_OS_WIN32
  40 #include <windows.h>
  41 #include <io.h>
  42 #endif /* G_OS_WIN32 */
  43
  44 #ifndef S_ISLNK
  45 #define S_ISLNK(x) 0
  46 #endif
  47
  48 #ifndef O_BINARY
  49 #define O_BINARY 0
  50 #endif
  51
  52 #include "gstdio.h"
  53 #include "glibintl.h"
  54
  55 #include "galias.h"
  56
  57 /**
  58  * g_mkdir_with_parents:
  59  * @pathname: a pathname in the GLib file name encoding
  60  * @mode: permissions to use for newly created directories
  61  *
  62  * Create a directory if it doesn't already exist. Create intermediate
  63  * parent directories as needed, too.
  64  *
  65  * Returns: 0 if the directory already exists, or was successfully
  66  * created. Returns -1 if an error occurred, with errno set.
  67  *
  68  * Since: 2.8
  69  */
  70 int
  71 g_mkdir_with_parents (const gchar *pathname,
  72                       int          mode)
  73 {
  74   gchar *fn, *p;
  75
  76   if (pathname == NULL || *pathname == '\0')
  77     {
  78       errno = EINVAL;
  79       return -1;
  80     }
  81
  82   fn = g_strdup (pathname);
  83
  84   if (g_path_is_absolute (fn))
  85     p = (gchar *) g_path_skip_root (fn);
  86   else
  87     p = fn;
  88
  89   do
  90     {
  91       while (*p && !G_IS_DIR_SEPARATOR (*p))
  92         p++;
  93
  94       if (!*p)
  95         p = NULL;
  96       else
  97         *p = '\0';
  98
  99       if (!g_file_test (fn, G_FILE_TEST_EXISTS))
 100         {
 101           if (g_mkdir (fn, mode) == -1)
 102             {
 103               int errno_save = errno;
 104               g_free (fn);
 105               errno = errno_save;
 106               return -1;
 107             }
 108         }
 109       else if (!g_file_test (fn, G_FILE_TEST_IS_DIR))
 110         {
 111           g_free (fn);
 112           errno = ENOTDIR;
 113           return -1;
 114         }
 115       if (p)
 116         {
 117           *p++ = G_DIR_SEPARATOR;
 118           while (*p && G_IS_DIR_SEPARATOR (*p))
 119             p++;
 120         }
 121     }
 122   while (p);
 123
 124   g_free (fn);
 125
 126   return 0;
 127 }
 128
 129 /**
 130  * g_file_test:
 131  * @filename: a filename to test in the GLib file name encoding
 132  * @test: bitfield of #GFileTest flags
 133  *
 134  * Returns %TRUE if any of the tests in the bitfield @test are
 135  * %TRUE. For example, <literal>(G_FILE_TEST_EXISTS |
 136  * G_FILE_TEST_IS_DIR)</literal> will return %TRUE if the file exists;
 137  * the check whether it's a directory doesn't matter since the existence
 138  * test is %TRUE. With the current set of available tests, there's no point
 139  * passing in more than one test at a time.
 140  *
 141  * Apart from %G_FILE_TEST_IS_SYMLINK all tests follow symbolic links,
 142  * so for a symbolic link to a regular file g_file_test() will return
 143  * %TRUE for both %G_FILE_TEST_IS_SYMLINK and %G_FILE_TEST_IS_REGULAR.
 144  *
 145  * Note, that for a dangling symbolic link g_file_test() will return
 146  * %TRUE for %G_FILE_TEST_IS_SYMLINK and %FALSE for all other flags.
 147  *
 148  * You should never use g_file_test() to test whether it is safe
 149  * to perform an operation, because there is always the possibility
 150  * of the condition changing before you actually perform the operation.
 151  * For example, you might think you could use %G_FILE_TEST_IS_SYMLINK
 152  * to know whether it is safe to write to a file without being
 153  * tricked into writing into a different location. It doesn't work!
 154  * |[
 155  * /&ast; DON'T DO THIS &ast;/
 156  *  if (!g_file_test (filename, G_FILE_TEST_IS_SYMLINK))
 157  *    {
 158  *      fd = g_open (filename, O_WRONLY);
 159  *      /&ast; write to fd &ast;/
 160  *    }
 161  * ]|
 162  *
 163  * Another thing to note is that %G_FILE_TEST_EXISTS and
 164  * %G_FILE_TEST_IS_EXECUTABLE are implemented using the access()
 165  * system call. This usually doesn't matter, but if your program
 166  * is setuid or setgid it means that these tests will give you
 167  * the answer for the real user ID and group ID, rather than the
 168  * effective user ID and group ID.
 169  *
 170  * On Windows, there are no symlinks, so testing for
 171  * %G_FILE_TEST_IS_SYMLINK will always return %FALSE. Testing for
 172  * %G_FILE_TEST_IS_EXECUTABLE will just check that the file exists and
 173  * its name indicates that it is executable, checking for well-known
 174  * extensions and those listed in the %PATHEXT environment variable.
 175  *
 176  * Return value: whether a test was %TRUE
 177  **/
 178 gboolean
 179 g_file_test (const gchar *filename,
 180              GFileTest    test)
 181 {
 182 #ifdef G_OS_WIN32
 183 /* stuff missing in std vc6 api */
 184 #  ifndef INVALID_FILE_ATTRIBUTES
 185 #    define INVALID_FILE_ATTRIBUTES -1
 186 #  endif
 187 #  ifndef FILE_ATTRIBUTE_DEVICE
 188 #    define FILE_ATTRIBUTE_DEVICE 64
 189 #  endif
 190   int attributes;
 191   wchar_t *wfilename = g_utf8_to_utf16 (filename, -1, NULL, NULL, NULL);
 192
 193   if (wfilename == NULL)
 194     return FALSE;
 195
 196   attributes = GetFileAttributesW (wfilename);
 197
 198   g_free (wfilename);
 199
 200   if (attributes == INVALID_FILE_ATTRIBUTES)
 201     return FALSE;
 202
 203   if (test & G_FILE_TEST_EXISTS)
 204     return TRUE;
 205
 206   if (test & G_FILE_TEST_IS_REGULAR)
 207     {
 208       if ((attributes & (FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_DEVICE)) == 0)
 209         return TRUE;
 210     }
 211
 212   if (test & G_FILE_TEST_IS_DIR)
 213     {
 214       if ((attributes & FILE_ATTRIBUTE_DIRECTORY) != 0)
 215         return TRUE;
 216     }
 217
 218   /* "while" so that we can exit this "loop" with a simple "break" */
 219   while (test & G_FILE_TEST_IS_EXECUTABLE)
 220     {
 221       const gchar *lastdot = strrchr (filename, '.');
 222       const gchar *pathext = NULL, *p;
 223       int extlen;
 224
 225       if (lastdot == NULL)
 226         break;
 227
 228       if (_stricmp (lastdot, ".exe") == 0 ||
 229           _stricmp (lastdot, ".cmd") == 0 ||
 230           _stricmp (lastdot, ".bat") == 0 ||
 231           _stricmp (lastdot, ".com") == 0)
 232         return TRUE;
 233
 234       /* Check if it is one of the types listed in %PATHEXT% */
 235
 236       pathext = g_getenv ("PATHEXT");
 237       if (pathext == NULL)
 238         break;
 239
 240       pathext = g_utf8_casefold (pathext, -1);
 241
 242       lastdot = g_utf8_casefold (lastdot, -1);
 243       extlen = strlen (lastdot);
 244
 245       p = pathext;
 246       while (TRUE)
 247         {
 248           const gchar *q = strchr (p, ';');
 249           if (q == NULL)
 250             q = p + strlen (p);
 251           if (extlen == q - p &&
 252               memcmp (lastdot, p, extlen) == 0)
 253             {
 254               g_free ((gchar *) pathext);
 255               g_free ((gchar *) lastdot);
 256               return TRUE;
 257             }
 258           if (*q)
 259             p = q + 1;
 260           else
 261             break;
 262         }
 263
 264       g_free ((gchar *) pathext);
 265       g_free ((gchar *) lastdot);
 266       break;
 267     }
 268
 269   return FALSE;
 270 #else
 271   if ((test & G_FILE_TEST_EXISTS) && (access (filename, F_OK) == 0))
 272     return TRUE;
 273
 274   if ((test & G_FILE_TEST_IS_EXECUTABLE) && (access (filename, X_OK) == 0))
 275     {
 276       if (getuid () != 0)
 277         return TRUE;
 278
 279       /* For root, on some POSIX systems, access (filename, X_OK)
 280        * will succeed even if no executable bits are set on the
 281        * file. We fall through to a stat test to avoid that.
 282        */
 283     }
 284   else
 285     test &= ~G_FILE_TEST_IS_EXECUTABLE;
 286
 287   if (test & G_FILE_TEST_IS_SYMLINK)
 288     {
 289       struct stat s;
 290
 291       if ((lstat (filename, &s) == 0) && S_ISLNK (s.st_mode))
 292         return TRUE;
 293     }
 294
 295   if (test & (G_FILE_TEST_IS_REGULAR |
 296               G_FILE_TEST_IS_DIR |
 297               G_FILE_TEST_IS_EXECUTABLE))
 298     {
 299       struct stat s;
 300
 301       if (stat (filename, &s) == 0)
 302         {
 303           if ((test & G_FILE_TEST_IS_REGULAR) && S_ISREG (s.st_mode))
 304             return TRUE;
 305
 306           if ((test & G_FILE_TEST_IS_DIR) && S_ISDIR (s.st_mode))
 307             return TRUE;
 308
 309           /* The extra test for root when access (file, X_OK) succeeds.
 310            */
 311           if ((test & G_FILE_TEST_IS_EXECUTABLE) &&
 312               ((s.st_mode & S_IXOTH) ||
 313                (s.st_mode & S_IXUSR) ||
 314                (s.st_mode & S_IXGRP)))
 315             return TRUE;
 316         }
 317     }
 318
 319   return FALSE;
 320 #endif
 321 }
 322
 323 GQuark
 324 g_file_error_quark (void)
 325 {
 326   return g_quark_from_static_string ("g-file-error-quark");
 327 }
 328
 329 /**
 330  * g_file_error_from_errno:
 331  * @err_no: an "errno" value
 332  *
 333  * Gets a #GFileError constant based on the passed-in @errno.
 334  * For example, if you pass in %EEXIST this function returns
 335  * #G_FILE_ERROR_EXIST. Unlike @errno values, you can portably
 336  * assume that all #GFileError values will exist.
 337  *
 338  * Normally a #GFileError value goes into a #GError returned
 339  * from a function that manipulates files. So you would use
 340  * g_file_error_from_errno() when constructing a #GError.
 341  *
 342  * Return value: #GFileError corresponding to the given @errno
 343  **/
 344 GFileError
 345 g_file_error_from_errno (gint err_no)
 346 {
 347   switch (err_no)
 348     {
 349 #ifdef EEXIST
 350     case EEXIST:
 351       return G_FILE_ERROR_EXIST;
 352       break;
 353 #endif
 354
 355 #ifdef EISDIR
 356     case EISDIR:
 357       return G_FILE_ERROR_ISDIR;
 358       break;
 359 #endif
 360
 361 #ifdef EACCES
 362     case EACCES:
 363       return G_FILE_ERROR_ACCES;
 364       break;
 365 #endif
 366
 367 #ifdef ENAMETOOLONG
 368     case ENAMETOOLONG:
 369       return G_FILE_ERROR_NAMETOOLONG;
 370       break;
 371 #endif
 372
 373 #ifdef ENOENT
 374     case ENOENT:
 375       return G_FILE_ERROR_NOENT;
 376       break;
 377 #endif
 378
 379 #ifdef ENOTDIR
 380     case ENOTDIR:
 381       return G_FILE_ERROR_NOTDIR;
 382       break;
 383 #endif
 384
 385 #ifdef ENXIO
 386     case ENXIO:
 387       return G_FILE_ERROR_NXIO;
 388       break;
 389 #endif
 390
 391 #ifdef ENODEV
 392     case ENODEV:
 393       return G_FILE_ERROR_NODEV;
 394       break;
 395 #endif
 396
 397 #ifdef EROFS
 398     case EROFS:
 399       return G_FILE_ERROR_ROFS;
 400       break;
 401 #endif
 402
 403 #ifdef ETXTBSY
 404     case ETXTBSY:
 405       return G_FILE_ERROR_TXTBSY;
 406       break;
 407 #endif
 408
 409 #ifdef EFAULT
 410     case EFAULT:
 411       return G_FILE_ERROR_FAULT;
 412       break;
 413 #endif
 414
 415 #ifdef ELOOP
 416     case ELOOP:
 417       return G_FILE_ERROR_LOOP;
 418       break;
 419 #endif
 420
 421 #ifdef ENOSPC
 422     case ENOSPC:
 423       return G_FILE_ERROR_NOSPC;
 424       break;
 425 #endif
 426
 427 #ifdef ENOMEM
 428     case ENOMEM:
 429       return G_FILE_ERROR_NOMEM;
 430       break;
 431 #endif
 432
 433 #ifdef EMFILE
 434     case EMFILE:
 435       return G_FILE_ERROR_MFILE;
 436       break;
 437 #endif
 438
 439 #ifdef ENFILE
 440     case ENFILE:
 441       return G_FILE_ERROR_NFILE;
 442       break;
 443 #endif
 444
 445 #ifdef EBADF
 446     case EBADF:
 447       return G_FILE_ERROR_BADF;
 448       break;
 449 #endif
 450
 451 #ifdef EINVAL
 452     case EINVAL:
 453       return G_FILE_ERROR_INVAL;
 454       break;
 455 #endif
 456
 457 #ifdef EPIPE
 458     case EPIPE:
 459       return G_FILE_ERROR_PIPE;
 460       break;
 461 #endif
 462
 463 #ifdef EAGAIN
 464     case EAGAIN:
 465       return G_FILE_ERROR_AGAIN;
 466       break;
 467 #endif
 468
 469 #ifdef EINTR
 470     case EINTR:
 471       return G_FILE_ERROR_INTR;
 472       break;
 473 #endif
 474
 475 #ifdef EIO
 476     case EIO:
 477       return G_FILE_ERROR_IO;
 478       break;
 479 #endif
 480
 481 #ifdef EPERM
 482     case EPERM:
 483       return G_FILE_ERROR_PERM;
 484       break;
 485 #endif
 486
 487 #ifdef ENOSYS
 488     case ENOSYS:
 489       return G_FILE_ERROR_NOSYS;
 490       break;
 491 #endif
 492
 493     default:
 494       return G_FILE_ERROR_FAILED;
 495       break;
 496     }
 497 }
 498
 499 static gboolean
 500 get_contents_stdio (const gchar  *display_filename,
 501                     FILE         *f,
 502                     gchar       **contents,
 503                     gsize        *length,
 504                     GError      **error)
 505 {
 506   gchar buf[4096];
 507   gsize bytes;
 508   gchar *str = NULL;
 509   gsize total_bytes = 0;
 510   gsize total_allocated = 0;
 511   gchar *tmp;
 512
 513   g_assert (f != NULL);
 514
 515   while (!feof (f))
 516     {
 517       gint save_errno;
 518
 519       bytes = fread (buf, 1, sizeof (buf), f);
 520       save_errno = errno;
 521
 522       while ((total_bytes + bytes + 1) > total_allocated)
 523         {
 524           if (str)
 525             total_allocated *= 2;
 526           else
 527             total_allocated = MIN (bytes + 1, sizeof (buf));
 528
 529           tmp = g_try_realloc (str, total_allocated);
 530
 531           if (tmp == NULL)
 532             {
 533               g_set_error (error,
 534                            G_FILE_ERROR,
 535                            G_FILE_ERROR_NOMEM,
 536                            _("Could not allocate %lu bytes to read file \"%s\""),
 537                            (gulong) total_allocated,
 538                            display_filename);
 539
 540               goto error;
 541             }
 542
 543           str = tmp;
 544         }
 545
 546       if (ferror (f))
 547         {
 548           g_set_error (error,
 549                        G_FILE_ERROR,
 550                        g_file_error_from_errno (save_errno),
 551                        _("Error reading file '%s': %s"),
 552                        display_filename,
 553                        g_strerror (save_errno));
 554
 555           goto error;
 556         }
 557
 558       memcpy (str + total_bytes, buf, bytes);
 559
 560       if (total_bytes + bytes < total_bytes)
 561         {
 562           g_set_error (error,
 563                        G_FILE_ERROR,
 564                        G_FILE_ERROR_FAILED,
 565                        _("File \"%s\" is too large"),
 566                        display_filename);
 567
 568           goto error;
 569         }
 570
 571       total_bytes += bytes;
 572     }
 573
 574   fclose (f);
 575
 576   if (total_allocated == 0)
 577     {
 578       str = g_new (gchar, 1);
 579       total_bytes = 0;
 580     }
 581
 582   str[total_bytes] = '\0';
 583
 584   if (length)
 585     *length = total_bytes;
 586
 587   *contents = str;
 588
 589   return TRUE;
 590
 591  error:
 592
 593   g_free (str);
 594   fclose (f);
 595
 596   return FALSE;
 597 }
 598
 599 #ifndef G_OS_WIN32
 600
 601 static gboolean
 602 get_contents_regfile (const gchar  *display_filename,
 603                       struct stat  *stat_buf,
 604                       gint          fd,
 605                       gchar       **contents,
 606                       gsize        *length,
 607                       GError      **error)
 608 {
 609   gchar *buf;
 610   gsize bytes_read;
 611   gsize size;
 612   gsize alloc_size;
 613
 614   size = stat_buf->st_size;
 615
 616   alloc_size = size + 1;
 617   buf = g_try_malloc (alloc_size);
 618
 619   if (buf == NULL)
 620     {
 621       g_set_error (error,
 622                    G_FILE_ERROR,
 623                    G_FILE_ERROR_NOMEM,
 624                    _("Could not allocate %lu bytes to read file \"%s\""),
 625                    (gulong) alloc_size,
 626                    display_filename);
 627
 628       goto error;
 629     }
 630
 631   bytes_read = 0;
 632   while (bytes_read < size)
 633     {
 634       gssize rc;
 635
 636       rc = read (fd, buf + bytes_read, size - bytes_read);
 637
 638       if (rc < 0)
 639         {
 640           if (errno != EINTR)
 641             {
 642               int save_errno = errno;
 643
 644               g_free (buf);
 645               g_set_error (error,
 646                            G_FILE_ERROR,
 647                            g_file_error_from_errno (save_errno),
 648                            _("Failed to read from file '%s': %s"),
 649                            display_filename,
 650                            g_strerror (save_errno));
 651
 652               goto error;
 653             }
 654         }
 655       else if (rc == 0)
 656         break;
 657       else
 658         bytes_read += rc;
 659     }
 660
 661   buf[bytes_read] = '\0';
 662
 663   if (length)
 664     *length = bytes_read;
 665
 666   *contents = buf;
 667
 668   close (fd);
 669
 670   return TRUE;
 671
 672  error:
 673
 674   close (fd);
 675
 676   return FALSE;
 677 }
 678
 679 static gboolean
 680 get_contents_posix (const gchar  *filename,
 681                     gchar       **contents,
 682                     gsize        *length,
 683                     GError      **error)
 684 {
 685   struct stat stat_buf;
 686   gint fd;
 687   gchar *display_filename = g_filename_display_name (filename);
 688
 689   /* O_BINARY useful on Cygwin */
 690   fd = open (filename, O_RDONLY|O_BINARY);
 691
 692   if (fd < 0)
 693     {
 694       int save_errno = errno;
 695
 696       g_set_error (error,
 697                    G_FILE_ERROR,
 698                    g_file_error_from_errno (save_errno),
 699                    _("Failed to open file '%s': %s"),
 700                    display_filename,
 701                    g_strerror (save_errno));
 702       g_free (display_filename);
 703
 704       return FALSE;
 705     }
 706
 707   /* I don't think this will ever fail, aside from ENOMEM, but. */
 708   if (fstat (fd, &stat_buf) < 0)
 709     {
 710       int save_errno = errno;
 711
 712       close (fd);
 713       g_set_error (error,
 714                    G_FILE_ERROR,
 715                    g_file_error_from_errno (save_errno),
 716                    _("Failed to get attributes of file '%s': fstat() failed: %s"),
 717                    display_filename,
 718                    g_strerror (save_errno));
 719       g_free (display_filename);
 720
 721       return FALSE;
 722     }
 723
 724   if (stat_buf.st_size > 0 && S_ISREG (stat_buf.st_mode))
 725     {
 726       gboolean retval = get_contents_regfile (display_filename,
 727                                               &stat_buf,
 728                                               fd,
 729                                               contents,
 730                                               length,
 731                                               error);
 732       g_free (display_filename);
 733
 734       return retval;
 735     }
 736   else
 737     {
 738       FILE *f;
 739       gboolean retval;
 740
 741       f = fdopen (fd, "r");
 742
 743       if (f == NULL)
 744         {
 745           int save_errno = errno;
 746
 747           g_set_error (error,
 748                        G_FILE_ERROR,
 749                        g_file_error_from_errno (save_errno),
 750                        _("Failed to open file '%s': fdopen() failed: %s"),
 751                        display_filename,
 752                        g_strerror (save_errno));
 753           g_free (display_filename);
 754
 755           return FALSE;
 756         }
 757
 758       retval = get_contents_stdio (display_filename, f, contents, length, error);
 759       g_free (display_filename);
 760
 761       return retval;
 762     }
 763 }
 764
 765 #else  /* G_OS_WIN32 */
 766
 767 static gboolean
 768 get_contents_win32 (const gchar  *filename,
 769                     gchar       **contents,
 770                     gsize        *length,
 771                     GError      **error)
 772 {
 773   FILE *f;
 774   gboolean retval;
 775   gchar *display_filename = g_filename_display_name (filename);
 776   int save_errno;
 777
 778   f = g_fopen (filename, "rb");
 779   save_errno = errno;
 780
 781   if (f == NULL)
 782     {
 783       g_set_error (error,
 784                    G_FILE_ERROR,
 785                    g_file_error_from_errno (save_errno),
 786                    _("Failed to open file '%s': %s"),
 787                    display_filename,
 788                    g_strerror (save_errno));
 789       g_free (display_filename);
 790
 791       return FALSE;
 792     }
 793
 794   retval = get_contents_stdio (display_filename, f, contents, length, error);
 795   g_free (display_filename);
 796
 797   return retval;
 798 }
 799
 800 #endif
 801
 802 /**
 803  * g_file_get_contents:
 804  * @filename: name of a file to read contents from, in the GLib file name encoding
 805  * @contents: location to store an allocated string, use g_free() to free
 806  *     the returned string
 807  * @length: location to store length in bytes of the contents, or %NULL
 808  * @error: return location for a #GError, or %NULL
 809  *
 810  * Reads an entire file into allocated memory, with good error
 811  * checking.
 812  *
 813  * If the call was successful, it returns %TRUE and sets @contents to the file
 814  * contents and @length to the length of the file contents in bytes. The string
 815  * stored in @contents will be nul-terminated, so for text files you can pass
 816  * %NULL for the @length argument. If the call was not successful, it returns
 817  * %FALSE and sets @error. The error domain is #G_FILE_ERROR. Possible error
 818  * codes are those in the #GFileError enumeration. In the error case,
 819  * @contents is set to %NULL and @length is set to zero.
 820  *
 821  * Return value: %TRUE on success, %FALSE if an error occurred
 822  **/
 823 gboolean
 824 g_file_get_contents (const gchar  *filename,
 825                      gchar       **contents,
 826                      gsize        *length,
 827                      GError      **error)
 828 {
 829   g_return_val_if_fail (filename != NULL, FALSE);
 830   g_return_val_if_fail (contents != NULL, FALSE);
 831
 832   *contents = NULL;
 833   if (length)
 834     *length = 0;
 835
 836 #ifdef G_OS_WIN32
 837   return get_contents_win32 (filename, contents, length, error);
 838 #else
 839   return get_contents_posix (filename, contents, length, error);
 840 #endif
 841 }
 842
 843 static gboolean
 844 rename_file (const char  *old_name,
 845              const char  *new_name,
 846              GError     **err)
 847 {
 848   errno = 0;
 849   if (g_rename (old_name, new_name) == -1)
 850     {
 851       int save_errno = errno;
 852       gchar *display_old_name = g_filename_display_name (old_name);
 853       gchar *display_new_name = g_filename_display_name (new_name);
 854
 855       g_set_error (err,
 856                    G_FILE_ERROR,
 857                    g_file_error_from_errno (save_errno),
 858                    _("Failed to rename file '%s' to '%s': g_rename() failed: %s"),
 859                    display_old_name,
 860                    display_new_name,
 861                    g_strerror (save_errno));
 862
 863       g_free (display_old_name);
 864       g_free (display_new_name);
 865
 866       return FALSE;
 867     }
 868
 869   return TRUE;
 870 }
 871
 872 static gchar *
 873 write_to_temp_file (const gchar  *contents,
 874                     gssize        length,
 875                     const gchar  *dest_file,
 876                     GError      **err)
 877 {
 878   gchar *tmp_name;
 879   gchar *display_name;
 880   gchar *retval;
 881   FILE *file;
 882   gint fd;
 883   int save_errno;
 884
 885   retval = NULL;
 886
 887   tmp_name = g_strdup_printf ("%s.XXXXXX", dest_file);
 888
 889   errno = 0;
 890   fd = g_mkstemp_full (tmp_name, O_RDWR | O_BINARY, 0666);
 891   save_errno = errno;
 892
 893   display_name = g_filename_display_name (tmp_name);
 894
 895   if (fd == -1)
 896     {
 897       g_set_error (err,
 898                    G_FILE_ERROR,
 899                    g_file_error_from_errno (save_errno),
 900                    _("Failed to create file '%s': %s"),
 901                    display_name, g_strerror (save_errno));
 902
 903       goto out;
 904     }
 905
 906   errno = 0;
 907   file = fdopen (fd, "wb");
 908   if (!file)
 909     {
 910       save_errno = errno;
 911       g_set_error (err,
 912                    G_FILE_ERROR,
 913                    g_file_error_from_errno (save_errno),
 914                    _("Failed to open file '%s' for writing: fdopen() failed: %s"),
 915                    display_name,
 916                    g_strerror (save_errno));
 917
 918       close (fd);
 919       g_unlink (tmp_name);
 920
 921       goto out;
 922     }
 923
 924   if (length > 0)
 925     {
 926       gsize n_written;
 927
 928       errno = 0;
 929
 930       n_written = fwrite (contents, 1, length, file);
 931
 932       if (n_written < length)
 933         {
 934           save_errno = errno;
 935
 936           g_set_error (err,
 937                        G_FILE_ERROR,
 938                        g_file_error_from_errno (save_errno),
 939                        _("Failed to write file '%s': fwrite() failed: %s"),
 940                        display_name,
 941                        g_strerror (save_errno));
 942
 943           fclose (file);
 944           g_unlink (tmp_name);
 945
 946           goto out;
 947         }
 948     }
 949
 950   errno = 0;
 951   if (fflush (file) != 0)
 952     {
 953       save_errno = errno;
 954
 955       g_set_error (err,
 956                    G_FILE_ERROR,
 957                    g_file_error_from_errno (save_errno),
 958                    _("Failed to write file '%s': fflush() failed: %s"),
 959                    display_name,
 960                    g_strerror (save_errno));
 961
 962       g_unlink (tmp_name);
 963
 964       goto out;
 965     }
 966
 967 #ifdef HAVE_FSYNC
 968   {
 969     struct stat statbuf;
 970
 971     errno = 0;
 972     /* If the final destination exists and is > 0 bytes, we want to sync the
 973      * newly written file to ensure the data is on disk when we rename over
 974      * the destination. Otherwise if we get a system crash we can lose both
 975      * the new and the old file on some filesystems. (I.E. those that don't
 976      * guarantee the data is written to the disk before the metadata.)
 977      */
 978     if (g_lstat (dest_file, &statbuf) == 0 &&
 979         statbuf.st_size > 0 &&
 980         fsync (fileno (file)) != 0)
 981       {
 982         save_errno = errno;
 983
 984         g_set_error (err,
 985                      G_FILE_ERROR,
 986                      g_file_error_from_errno (save_errno),
 987                      _("Failed to write file '%s': fsync() failed: %s"),
 988                      display_name,
 989                      g_strerror (save_errno));
 990
 991         g_unlink (tmp_name);
 992
 993         goto out;
 994       }
 995   }
 996 #endif
 997
 998   errno = 0;
 999   if (fclose (file) == EOF)
1000     {
1001       save_errno = errno;
1002
1003       g_set_error (err,
1004                    G_FILE_ERROR,
1005                    g_file_error_from_errno (save_errno),
1006                    _("Failed to close file '%s': fclose() failed: %s"),
1007                    display_name,
1008                    g_strerror (save_errno));
1009
1010       g_unlink (tmp_name);
1011
1012       goto out;
1013     }
1014
1015   retval = g_strdup (tmp_name);
1016
1017  out:
1018   g_free (tmp_name);
1019   g_free (display_name);
1020
1021   return retval;
1022 }
1023
1024 /**
1025  * g_file_set_contents:
1026  * @filename: name of a file to write @contents to, in the GLib file name
1027  *   encoding
1028  * @contents: string to write to the file
1029  * @length: length of @contents, or -1 if @contents is a nul-terminated string
1030  * @error: return location for a #GError, or %NULL
1031  *
1032  * Writes all of @contents to a file named @filename, with good error checking.
1033  * If a file called @filename already exists it will be overwritten.
1034  *
1035  * This write is atomic in the sense that it is first written to a temporary
1036  * file which is then renamed to the final name. Notes:
1037  * <itemizedlist>
1038  * <listitem>
1039  *    On Unix, if @filename already exists hard links to @filename will break.
1040  *    Also since the file is recreated, existing permissions, access control
1041  *    lists, metadata etc. may be lost. If @filename is a symbolic link,
1042  *    the link itself will be replaced, not the linked file.
1043  * </listitem>
1044  * <listitem>
1045  *   On Windows renaming a file will not remove an existing file with the
1046  *   new name, so on Windows there is a race condition between the existing
1047  *   file being removed and the temporary file being renamed.
1048  * </listitem>
1049  * <listitem>
1050  *   On Windows there is no way to remove a file that is open to some
1051  *   process, or mapped into memory. Thus, this function will fail if
1052  *   @filename already exists and is open.
1053  * </listitem>
1054  * </itemizedlist>
1055  *
1056  * If the call was sucessful, it returns %TRUE. If the call was not successful,
1057  * it returns %FALSE and sets @error. The error domain is #G_FILE_ERROR.
1058  * Possible error codes are those in the #GFileError enumeration.
1059  *
1060  * Return value: %TRUE on success, %FALSE if an error occurred
1061  *
1062  * Since: 2.8
1063  **/
1064 gboolean
1065 g_file_set_contents (const gchar  *filename,
1066                      const gchar  *contents,
1067                      gssize        length,
1068                      GError      **error)
1069 {
1070   gchar *tmp_filename;
1071   gboolean retval;
1072   GError *rename_error = NULL;
1073
1074   g_return_val_if_fail (filename != NULL, FALSE);
1075   g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
1076   g_return_val_if_fail (contents != NULL || length == 0, FALSE);
1077   g_return_val_if_fail (length >= -1, FALSE);
1078
1079   if (length == -1)
1080     length = strlen (contents);
1081
1082   tmp_filename = write_to_temp_file (contents, length, filename, error);
1083
1084   if (!tmp_filename)
1085     {
1086       retval = FALSE;
1087       goto out;
1088     }
1089
1090   if (!rename_file (tmp_filename, filename, &rename_error))
1091     {
1092 #ifndef G_OS_WIN32
1093
1094       g_unlink (tmp_filename);
1095       g_propagate_error (error, rename_error);
1096       retval = FALSE;
1097       goto out;
1098
1099 #else /* G_OS_WIN32 */
1100
1101       /* Renaming failed, but on Windows this may just mean
1102        * the file already exists. So if the target file
1103        * exists, try deleting it and do the rename again.
1104        */
1105       if (!g_file_test (filename, G_FILE_TEST_EXISTS))
1106         {
1107           g_unlink (tmp_filename);
1108           g_propagate_error (error, rename_error);
1109           retval = FALSE;
1110           goto out;
1111         }
1112
1113       g_error_free (rename_error);
1114
1115       if (g_unlink (filename) == -1)
1116         {
1117           gchar *display_filename = g_filename_display_name (filename);
1118
1119           int save_errno = errno;
1120
1121           g_set_error (error,
1122                        G_FILE_ERROR,
1123                        g_file_error_from_errno (save_errno),
1124                        _("Existing file '%s' could not be removed: g_unlink() failed: %s"),
1125                        display_filename,
1126                        g_strerror (save_errno));
1127
1128           g_free (display_filename);
1129           g_unlink (tmp_filename);
1130           retval = FALSE;
1131           goto out;
1132         }
1133
1134       if (!rename_file (tmp_filename, filename, error))
1135         {
1136           g_unlink (tmp_filename);
1137           retval = FALSE;
1138           goto out;
1139         }
1140
1141 #endif
1142     }
1143
1144   retval = TRUE;
1145
1146  out:
1147   g_free (tmp_filename);
1148   return retval;
1149 }
1150
1151 /**
1152  * g_mkstemp_full:
1153  * @tmpl: template filename
1154  * @flags: flags to pass to an open() call in addition to O_EXCL and
1155  *         O_CREAT, which are passed automatically
1156  * @mode: permissios to create the temporary file with
1157  *
1158  * Opens a temporary file. See the mkstemp() documentation
1159  * on most UNIX-like systems.
1160  *
1161  * The parameter is a string that should follow the rules for
1162  * mkstemp() templates, i.e. contain the string "XXXXXX".
1163  * g_mkstemp_full() is slightly more flexible than mkstemp()
1164  * in that the sequence does not have to occur at the very end of the
1165  * template and you can pass a @mode and additional @flags. The X
1166  * string will be modified to form the name of a file that didn't exist.
1167  * The string should be in the GLib file name encoding. Most importantly,
1168  * on Windows it should be in UTF-8.
1169  *
1170  * Return value: A file handle (as from open()) to the file
1171  *     opened for reading and writing. The file handle should be
1172  *     closed with close(). In case of errors, -1 is returned.
1173  *
1174  * Since: 2.22
1175  */
1176 /*
1177  * g_mkstemp_full based on the mkstemp implementation from the GNU C library.
1178  * Copyright (C) 1991,92,93,94,95,96,97,98,99 Free Software Foundation, Inc.
1179  */
1180 gint
1181 g_mkstemp_full (gchar *tmpl,
1182                 int    flags,
1183                 int    mode)
1184 {
1185   char *XXXXXX;
1186   int count, fd;
1187   static const char letters[] =
1188     "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
1189   static const int NLETTERS = sizeof (letters) - 1;
1190   glong value;
1191   GTimeVal tv;
1192   static int counter = 0;
1193
1194   g_return_val_if_fail (tmpl != NULL, -1);
1195
1196
1197   /* find the last occurrence of "XXXXXX" */
1198   XXXXXX = g_strrstr (tmpl, "XXXXXX");
1199
1200   if (!XXXXXX || strncmp (XXXXXX, "XXXXXX", 6))
1201     {
1202       errno = EINVAL;
1203       return -1;
1204     }
1205
1206   /* Get some more or less random data.  */
1207   g_get_current_time (&tv);
1208   value = (tv.tv_usec ^ tv.tv_sec) + counter++;
1209
1210   for (count = 0; count < 100; value += 7777, ++count)
1211     {
1212       glong v = value;
1213
1214       /* Fill in the random bits.  */
1215       XXXXXX[0] = letters[v % NLETTERS];
1216       v /= NLETTERS;
1217       XXXXXX[1] = letters[v % NLETTERS];
1218       v /= NLETTERS;
1219       XXXXXX[2] = letters[v % NLETTERS];
1220       v /= NLETTERS;
1221       XXXXXX[3] = letters[v % NLETTERS];
1222       v /= NLETTERS;
1223       XXXXXX[4] = letters[v % NLETTERS];
1224       v /= NLETTERS;
1225       XXXXXX[5] = letters[v % NLETTERS];
1226
1227       /* tmpl is in UTF-8 on Windows, thus use g_open() */
1228       fd = g_open (tmpl, flags | O_CREAT | O_EXCL, mode);
1229
1230       if (fd >= 0)
1231         return fd;
1232       else if (errno != EEXIST)
1233         /* Any other error will apply also to other names we might
1234          *  try, and there are 2^32 or so of them, so give up now.
1235          */
1236         return -1;
1237     }
1238
1239   /* We got out of the loop because we ran out of combinations to try.  */
1240   errno = EEXIST;
1241   return -1;
1242 }
1243
1244 /**
1245  * g_mkstemp:
1246  * @tmpl: template filename
1247  *
1248  * Opens a temporary file. See the mkstemp() documentation
1249  * on most UNIX-like systems.
1250  *
1251  * The parameter is a string that should follow the rules for
1252  * mkstemp() templates, i.e. contain the string "XXXXXX".
1253  * g_mkstemp() is slightly more flexible than mkstemp()
1254  * in that the sequence does not have to occur at the very end of the
1255  * template. The X string will
1256  * be modified to form the name of a file that didn't exist.
1257  * The string should be in the GLib file name encoding. Most importantly,
1258  * on Windows it should be in UTF-8.
1259  *
1260  * Return value: A file handle (as from open()) to the file
1261  * opened for reading and writing. The file is opened in binary mode
1262  * on platforms where there is a difference. The file handle should be
1263  * closed with close(). In case of errors, -1 is returned.
1264  */
1265 gint
1266 g_mkstemp (gchar *tmpl)
1267 {
1268   return g_mkstemp_full (tmpl, O_RDWR | O_BINARY, 0600);
1269 }
1270
1271 /**
1272  * g_file_open_tmp:
1273  * @tmpl: Template for file name, as in g_mkstemp(), basename only,
1274  *        or %NULL, to a default template
1275  * @name_used: location to store actual name used, or %NULL
1276  * @error: return location for a #GError
1277  *
1278  * Opens a file for writing in the preferred directory for temporary
1279  * files (as returned by g_get_tmp_dir()).
1280  *
1281  * @tmpl should be a string in the GLib file name encoding containing
1282  * a sequence of six 'X' characters, as the parameter to g_mkstemp().
1283  * However, unlike these functions, the template should only be a
1284  * basename, no directory components are allowed. If template is
1285  * %NULL, a default template is used.
1286  *
1287  * Note that in contrast to g_mkstemp() (and mkstemp())
1288  * @tmpl is not modified, and might thus be a read-only literal string.
1289  *
1290  * The actual name used is returned in @name_used if non-%NULL. This
1291  * string should be freed with g_free() when not needed any longer.
1292  * The returned name is in the GLib file name encoding.
1293  *
1294  * Return value: A file handle (as from open()) to
1295  * the file opened for reading and writing. The file is opened in binary
1296  * mode on platforms where there is a difference. The file handle should be
1297  * closed with close(). In case of errors, -1 is returned
1298  * and @error will be set.
1299  **/
1300 gint
1301 g_file_open_tmp (const gchar  *tmpl,
1302                  gchar       **name_used,
1303                  GError      **error)
1304 {
1305   int retval;
1306   const char *tmpdir;
1307   const char *sep;
1308   char *fulltemplate;
1309   const char *slash;
1310
1311   if (tmpl == NULL)
1312     tmpl = ".XXXXXX";
1313
1314   if ((slash = strchr (tmpl, G_DIR_SEPARATOR)) != NULL
1315 #ifdef G_OS_WIN32
1316       || (strchr (tmpl, '/') != NULL && (slash = "/"))
1317 #endif
1318       )
1319     {
1320       gchar *display_tmpl = g_filename_display_name (tmpl);
1321       char c[2];
1322       c[0] = *slash;
1323       c[1] = '\0';
1324
1325       g_set_error (error,
1326                    G_FILE_ERROR,
1327                    G_FILE_ERROR_FAILED,
1328                    _("Template '%s' invalid, should not contain a '%s'"),
1329                    display_tmpl, c);
1330       g_free (display_tmpl);
1331
1332       return -1;
1333     }
1334
1335   if (strstr (tmpl, "XXXXXX") == NULL)
1336     {
1337       gchar *display_tmpl = g_filename_display_name (tmpl);
1338       g_set_error (error,
1339                    G_FILE_ERROR,
1340                    G_FILE_ERROR_FAILED,
1341                    _("Template '%s' doesn't contain XXXXXX"),
1342                    display_tmpl);
1343       g_free (display_tmpl);
1344       return -1;
1345     }
1346
1347   tmpdir = g_get_tmp_dir ();
1348
1349   if (G_IS_DIR_SEPARATOR (tmpdir [strlen (tmpdir) - 1]))
1350     sep = "";
1351   else
1352     sep = G_DIR_SEPARATOR_S;
1353
1354   fulltemplate = g_strconcat (tmpdir, sep, tmpl, NULL);
1355
1356   retval = g_mkstemp (fulltemplate);
1357
1358   if (retval == -1)
1359     {
1360       int save_errno = errno;
1361       gchar *display_fulltemplate = g_filename_display_name (fulltemplate);
1362
1363       g_set_error (error,
1364                    G_FILE_ERROR,
1365                    g_file_error_from_errno (save_errno),
1366                    _("Failed to create file '%s': %s"),
1367                    display_fulltemplate, g_strerror (save_errno));
1368       g_free (display_fulltemplate);
1369       g_free (fulltemplate);
1370       return -1;
1371     }
1372
1373   if (name_used)
1374     *name_used = fulltemplate;
1375   else
1376     g_free (fulltemplate);
1377
1378   return retval;
1379 }
1380
1381 static gchar *
1382 g_build_path_va (const gchar  *separator,
1383                  const gchar  *first_element,
1384                  va_list      *args,
1385                  gchar       **str_array)
1386 {
1387   GString *result;
1388   gint separator_len = strlen (separator);
1389   gboolean is_first = TRUE;
1390   gboolean have_leading = FALSE;
1391   const gchar *single_element = NULL;
1392   const gchar *next_element;
1393   const gchar *last_trailing = NULL;
1394   gint i = 0;
1395
1396   result = g_string_new (NULL);
1397
1398   if (str_array)
1399     next_element = str_array[i++];
1400   else
1401     next_element = first_element;
1402
1403   while (TRUE)
1404     {
1405       const gchar *element;
1406       const gchar *start;
1407       const gchar *end;
1408
1409       if (next_element)
1410         {
1411           element = next_element;
1412           if (str_array)
1413             next_element = str_array[i++];
1414           else
1415             next_element = va_arg (*args, gchar *);
1416         }
1417       else
1418         break;
1419
1420       /* Ignore empty elements */
1421       if (!*element)
1422         continue;
1423
1424       start = element;
1425
1426       if (separator_len)
1427         {
1428           while (strncmp (start, separator, separator_len) == 0)
1429             start += separator_len;
1430         }
1431
1432       end = start + strlen (start);
1433
1434       if (separator_len)
1435         {
1436           while (end >= start + separator_len &&
1437                  strncmp (end - separator_len, separator, separator_len) == 0)
1438             end -= separator_len;
1439
1440           last_trailing = end;
1441           while (last_trailing >= element + separator_len &&
1442                  strncmp (last_trailing - separator_len, separator, separator_len) == 0)
1443             last_trailing -= separator_len;
1444
1445           if (!have_leading)
1446             {
1447               /* If the leading and trailing separator strings are in the
1448                * same element and overlap, the result is exactly that element
1449                */
1450               if (last_trailing <= start)
1451                 single_element = element;
1452
1453               g_string_append_len (result, element, start - element);
1454               have_leading = TRUE;
1455             }
1456           else
1457             single_element = NULL;
1458         }
1459
1460       if (end == start)
1461         continue;
1462
1463       if (!is_first)
1464         g_string_append (result, separator);
1465
1466       g_string_append_len (result, start, end - start);
1467       is_first = FALSE;
1468     }
1469
1470   if (single_element)
1471     {
1472       g_string_free (result, TRUE);
1473       return g_strdup (single_element);
1474     }
1475   else
1476     {
1477       if (last_trailing)
1478         g_string_append (result, last_trailing);
1479
1480       return g_string_free (result, FALSE);
1481     }
1482 }
1483
1484 /**
1485  * g_build_pathv:
1486  * @separator: a string used to separator the elements of the path.
1487  * @args: %NULL-terminated array of strings containing the path elements.
1488  *
1489  * Behaves exactly like g_build_path(), but takes the path elements
1490  * as a string array, instead of varargs. This function is mainly
1491  * meant for language bindings.
1492  *
1493  * Return value: a newly-allocated string that must be freed with g_free().
1494  *
1495  * Since: 2.8
1496  */
1497 gchar *
1498 g_build_pathv (const gchar  *separator,
1499                gchar       **args)
1500 {
1501   if (!args)
1502     return NULL;
1503
1504   return g_build_path_va (separator, NULL, NULL, args);
1505 }
1506
1507
1508 /**
1509  * g_build_path:
1510  * @separator: a string used to separator the elements of the path.
1511  * @first_element: the first element in the path
1512  * @Varargs: remaining elements in path, terminated by %NULL
1513  *
1514  * Creates a path from a series of elements using @separator as the
1515  * separator between elements. At the boundary between two elements,
1516  * any trailing occurrences of separator in the first element, or
1517  * leading occurrences of separator in the second element are removed
1518  * and exactly one copy of the separator is inserted.
1519  *
1520  * Empty elements are ignored.
1521  *
1522  * The number of leading copies of the separator on the result is
1523  * the same as the number of leading copies of the separator on
1524  * the first non-empty element.
1525  *
1526  * The number of trailing copies of the separator on the result is
1527  * the same as the number of trailing copies of the separator on
1528  * the last non-empty element. (Determination of the number of
1529  * trailing copies is done without stripping leading copies, so
1530  * if the separator is <literal>ABA</literal>, <literal>ABABA</literal>
1531  * has 1 trailing copy.)
1532  *
1533  * However, if there is only a single non-empty element, and there
1534  * are no characters in that element not part of the leading or
1535  * trailing separators, then the result is exactly the original value
1536  * of that element.
1537  *
1538  * Other than for determination of the number of leading and trailing
1539  * copies of the separator, elements consisting only of copies
1540  * of the separator are ignored.
1541  *
1542  * Return value: a newly-allocated string that must be freed with g_free().
1543  **/
1544 gchar *
1545 g_build_path (const gchar *separator,
1546               const gchar *first_element,
1547               ...)
1548 {
1549   gchar *str;
1550   va_list args;
1551
1552   g_return_val_if_fail (separator != NULL, NULL);
1553
1554   va_start (args, first_element);
1555   str = g_build_path_va (separator, first_element, &args, NULL);
1556   va_end (args);
1557
1558   return str;
1559 }
1560
1561 #ifdef G_OS_WIN32
1562
1563 static gchar *
1564 g_build_pathname_va (const gchar  *first_element,
1565                      va_list      *args,
1566                      gchar       **str_array)
1567 {
1568   /* Code copied from g_build_pathv(), and modified to use two
1569    * alternative single-character separators.
1570    */
1571   GString *result;
1572   gboolean is_first = TRUE;
1573   gboolean have_leading = FALSE;
1574   const gchar *single_element = NULL;
1575   const gchar *next_element;
1576   const gchar *last_trailing = NULL;
1577   gchar current_separator = '\\';
1578   gint i = 0;
1579
1580   result = g_string_new (NULL);
1581
1582   if (str_array)
1583     next_element = str_array[i++];
1584   else
1585     next_element = first_element;
1586
1587   while (TRUE)
1588     {
1589       const gchar *element;
1590       const gchar *start;
1591       const gchar *end;
1592
1593       if (next_element)
1594         {
1595           element = next_element;
1596           if (str_array)
1597             next_element = str_array[i++];
1598           else
1599             next_element = va_arg (*args, gchar *);
1600         }
1601       else
1602         break;
1603
1604       /* Ignore empty elements */
1605       if (!*element)
1606         continue;
1607
1608       start = element;
1609
1610       if (TRUE)
1611         {
1612           while (start &&
1613                  (*start == '\\' || *start == '/'))
1614             {
1615               current_separator = *start;
1616               start++;
1617             }
1618         }
1619
1620       end = start + strlen (start);
1621
1622       if (TRUE)
1623         {
1624           while (end >= start + 1 &&
1625                  (end[-1] == '\\' || end[-1] == '/'))
1626             {
1627               current_separator = end[-1];
1628               end--;
1629             }
1630
1631           last_trailing = end;
1632           while (last_trailing >= element + 1 &&
1633                  (last_trailing[-1] == '\\' || last_trailing[-1] == '/'))
1634             last_trailing--;
1635
1636           if (!have_leading)
1637             {
1638               /* If the leading and trailing separator strings are in the
1639                * same element and overlap, the result is exactly that element
1640                */
1641               if (last_trailing <= start)
1642                 single_element = element;
1643
1644               g_string_append_len (result, element, start - element);
1645               have_leading = TRUE;
1646             }
1647           else
1648             single_element = NULL;
1649         }
1650
1651       if (end == start)
1652         continue;
1653
1654       if (!is_first)
1655         g_string_append_len (result, &current_separator, 1);
1656
1657       g_string_append_len (result, start, end - start);
1658       is_first = FALSE;
1659     }
1660
1661   if (single_element)
1662     {
1663       g_string_free (result, TRUE);
1664       return g_strdup (single_element);
1665     }
1666   else
1667     {
1668       if (last_trailing)
1669         g_string_append (result, last_trailing);
1670
1671       return g_string_free (result, FALSE);
1672     }
1673 }
1674
1675 #endif
1676
1677 /**
1678  * g_build_filenamev:
1679  * @args: %NULL-terminated array of strings containing the path elements.
1680  *
1681  * Behaves exactly like g_build_filename(), but takes the path elements
1682  * as a string array, instead of varargs. This function is mainly
1683  * meant for language bindings.
1684  *
1685  * Return value: a newly-allocated string that must be freed with g_free().
1686  *
1687  * Since: 2.8
1688  */
1689 gchar *
1690 g_build_filenamev (gchar **args)
1691 {
1692   gchar *str;
1693
1694 #ifndef G_OS_WIN32
1695   str = g_build_path_va (G_DIR_SEPARATOR_S, NULL, NULL, args);
1696 #else
1697   str = g_build_pathname_va (NULL, NULL, args);
1698 #endif
1699
1700   return str;
1701 }
1702
1703 /**
1704  * g_build_filename:
1705  * @first_element: the first element in the path
1706  * @Varargs: remaining elements in path, terminated by %NULL
1707  *
1708  * Creates a filename from a series of elements using the correct
1709  * separator for filenames.
1710  *
1711  * On Unix, this function behaves identically to <literal>g_build_path
1712  * (G_DIR_SEPARATOR_S, first_element, ....)</literal>.
1713  *
1714  * On Windows, it takes into account that either the backslash
1715  * (<literal>\</literal> or slash (<literal>/</literal>) can be used
1716  * as separator in filenames, but otherwise behaves as on Unix. When
1717  * file pathname separators need to be inserted, the one that last
1718  * previously occurred in the parameters (reading from left to right)
1719  * is used.
1720  *
1721  * No attempt is made to force the resulting filename to be an absolute
1722  * path. If the first element is a relative path, the result will
1723  * be a relative path.
1724  *
1725  * Return value: a newly-allocated string that must be freed with g_free().
1726  **/
1727 gchar *
1728 g_build_filename (const gchar *first_element,
1729                   ...)
1730 {
1731   gchar *str;
1732   va_list args;
1733
1734   va_start (args, first_element);
1735 #ifndef G_OS_WIN32
1736   str = g_build_path_va (G_DIR_SEPARATOR_S, first_element, &args, NULL);
1737 #else
1738   str = g_build_pathname_va (first_element, &args, NULL);
1739 #endif
1740   va_end (args);
1741
1742   return str;
1743 }
1744
1745 #define KILOBYTE_FACTOR (G_GOFFSET_CONSTANT (1024))
1746 #define MEGABYTE_FACTOR (KILOBYTE_FACTOR * KILOBYTE_FACTOR)
1747 #define GIGABYTE_FACTOR (MEGABYTE_FACTOR * KILOBYTE_FACTOR)
1748 #define TERABYTE_FACTOR (GIGABYTE_FACTOR * KILOBYTE_FACTOR)
1749 #define PETABYTE_FACTOR (TERABYTE_FACTOR * KILOBYTE_FACTOR)
1750 #define EXABYTE_FACTOR  (PETABYTE_FACTOR * KILOBYTE_FACTOR)
1751
1752 /**
1753  * g_format_size_for_display:
1754  * @size: a size in bytes.
1755  *
1756  * Formats a size (for example the size of a file) into a human readable string.
1757  * Sizes are rounded to the nearest size prefix (KB, MB, GB) and are displayed
1758  * rounded to the nearest  tenth. E.g. the file size 3292528 bytes will be
1759  * converted into the string "3.1 MB".
1760  *
1761  * The prefix units base is 1024 (i.e. 1 KB is 1024 bytes).
1762  *
1763  * This string should be freed with g_free() when not needed any longer.
1764  *
1765  * Returns: a newly-allocated formatted string containing a human readable
1766  *          file size.
1767  *
1768  * Since: 2.16
1769  **/
1770 char *
1771 g_format_size_for_display (goffset size)
1772 {
1773   if (size < (goffset) KILOBYTE_FACTOR)
1774     return g_strdup_printf (g_dngettext(GETTEXT_PACKAGE, "%u byte", "%u bytes",(guint) size), (guint) size);
1775   else
1776     {
1777       gdouble displayed_size;
1778
1779       if (size < (goffset) MEGABYTE_FACTOR)
1780         {
1781           displayed_size = (gdouble) size / (gdouble) KILOBYTE_FACTOR;
1782           return g_strdup_printf (_("%.1f KB"), displayed_size);
1783         }
1784       else if (size < (goffset) GIGABYTE_FACTOR)
1785         {
1786           displayed_size = (gdouble) size / (gdouble) MEGABYTE_FACTOR;
1787           return g_strdup_printf (_("%.1f MB"), displayed_size);
1788         }
1789       else if (size < (goffset) TERABYTE_FACTOR)
1790         {
1791           displayed_size = (gdouble) size / (gdouble) GIGABYTE_FACTOR;
1792           return g_strdup_printf (_("%.1f GB"), displayed_size);
1793         }
1794       else if (size < (goffset) PETABYTE_FACTOR)
1795         {
1796           displayed_size = (gdouble) size / (gdouble) TERABYTE_FACTOR;
1797           return g_strdup_printf (_("%.1f TB"), displayed_size);
1798         }
1799       else if (size < (goffset) EXABYTE_FACTOR)
1800         {
1801           displayed_size = (gdouble) size / (gdouble) PETABYTE_FACTOR;
1802           return g_strdup_printf (_("%.1f PB"), displayed_size);
1803         }
1804       else
1805         {
1806           displayed_size = (gdouble) size / (gdouble) EXABYTE_FACTOR;
1807           return g_strdup_printf (_("%.1f EB"), displayed_size);
1808         }
1809     }
1810 }
1811
1812
1813 /**
1814  * g_file_read_link:
1815  * @filename: the symbolic link
1816  * @error: return location for a #GError
1817  *
1818  * Reads the contents of the symbolic link @filename like the POSIX
1819  * readlink() function.  The returned string is in the encoding used
1820  * for filenames. Use g_filename_to_utf8() to convert it to UTF-8.
1821  *
1822  * Returns: A newly-allocated string with the contents of the symbolic link,
1823  *          or %NULL if an error occurred.
1824  *
1825  * Since: 2.4
1826  */
1827 gchar *
1828 g_file_read_link (const gchar  *filename,
1829                   GError      **error)
1830 {
1831 #ifdef HAVE_READLINK
1832   gchar *buffer;
1833   guint size;
1834   gint read_size;
1835
1836   size = 256;
1837   buffer = g_malloc (size);
1838
1839   while (TRUE)
1840     {
1841       read_size = readlink (filename, buffer, size);
1842       if (read_size < 0) {
1843         int save_errno = errno;
1844         gchar *display_filename = g_filename_display_name (filename);
1845
1846         g_free (buffer);
1847         g_set_error (error,
1848                      G_FILE_ERROR,
1849                      g_file_error_from_errno (save_errno),
1850                      _("Failed to read the symbolic link '%s': %s"),
1851                      display_filename,
1852                      g_strerror (save_errno));
1853         g_free (display_filename);
1854
1855         return NULL;
1856       }
1857
1858       if (read_size < size)
1859         {
1860           buffer[read_size] = 0;
1861           return buffer;
1862         }
1863
1864       size *= 2;
1865       buffer = g_realloc (buffer, size);
1866     }
1867 #else
1868   g_set_error_literal (error,
1869                        G_FILE_ERROR,
1870                        G_FILE_ERROR_INVAL,
1871                        _("Symbolic links not supported"));
1872
1873   return NULL;
1874 #endif
1875 }
1876
1877 /* NOTE : Keep this part last to ensure nothing in this file uses the
1878  * below binary compatibility versions.
1879  */
1880 #if defined (G_OS_WIN32) && !defined (_WIN64)
1881
1882 /* Binary compatibility versions. Will be called by code compiled
1883  * against quite old (pre-2.8, I think) headers only, not from more
1884  * recently compiled code.
1885  */
1886
1887 #undef g_file_test
1888
1889 gboolean
1890 g_file_test (const gchar *filename,
1891              GFileTest    test)
1892 {
1893   gchar *utf8_filename = g_locale_to_utf8 (filename, -1, NULL, NULL, NULL);
1894   gboolean retval;
1895
1896   if (utf8_filename == NULL)
1897     return FALSE;
1898
1899   retval = g_file_test_utf8 (utf8_filename, test);
1900
1901   g_free (utf8_filename);
1902
1903   return retval;
1904 }
1905
1906 #undef g_file_get_contents
1907
1908 gboolean
1909 g_file_get_contents (const gchar  *filename,
1910                      gchar       **contents,
1911                      gsize        *length,
1912                      GError      **error)
1913 {
1914   gchar *utf8_filename = g_locale_to_utf8 (filename, -1, NULL, NULL, error);
1915   gboolean retval;
1916
1917   if (utf8_filename == NULL)
1918     return FALSE;
1919
1920   retval = g_file_get_contents_utf8 (utf8_filename, contents, length, error);
1921
1922   g_free (utf8_filename);
1923
1924   return retval;
1925 }
1926
1927 #undef g_mkstemp
1928
1929 gint
1930 g_mkstemp (gchar *tmpl)
1931 {
1932   char *XXXXXX;
1933   int count, fd;
1934   static const char letters[] =
1935     "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
1936   static const int NLETTERS = sizeof (letters) - 1;
1937   glong value;
1938   GTimeVal tv;
1939   static int counter = 0;
1940
1941   /* find the last occurrence of 'XXXXXX' */
1942   XXXXXX = g_strrstr (tmpl, "XXXXXX");
1943
1944   if (!XXXXXX)
1945     {
1946       errno = EINVAL;
1947       return -1;
1948     }
1949
1950   /* Get some more or less random data.  */
1951   g_get_current_time (&tv);
1952   value = (tv.tv_usec ^ tv.tv_sec) + counter++;
1953
1954   for (count = 0; count < 100; value += 7777, ++count)
1955     {
1956       glong v = value;
1957
1958       /* Fill in the random bits.  */
1959       XXXXXX[0] = letters[v % NLETTERS];
1960       v /= NLETTERS;
1961       XXXXXX[1] = letters[v % NLETTERS];
1962       v /= NLETTERS;
1963       XXXXXX[2] = letters[v % NLETTERS];
1964       v /= NLETTERS;
1965       XXXXXX[3] = letters[v % NLETTERS];
1966       v /= NLETTERS;
1967       XXXXXX[4] = letters[v % NLETTERS];
1968       v /= NLETTERS;
1969       XXXXXX[5] = letters[v % NLETTERS];
1970
1971       /* This is the backward compatibility system codepage version,
1972        * thus use normal open().
1973        */
1974       fd = open (tmpl, O_RDWR | O_CREAT | O_EXCL | O_BINARY, 0600);
1975
1976       if (fd >= 0)
1977         return fd;
1978       else if (errno != EEXIST)
1979         /* Any other error will apply also to other names we might
1980          *  try, and there are 2^32 or so of them, so give up now.
1981          */
1982         return -1;
1983     }
1984
1985   /* We got out of the loop because we ran out of combinations to try.  */
1986   errno = EEXIST;
1987   return -1;
1988 }
1989
1990 #undef g_file_open_tmp
1991
1992 gint
1993 g_file_open_tmp (const gchar  *tmpl,
1994                  gchar       **name_used,
1995                  GError      **error)
1996 {
1997   gchar *utf8_tmpl = g_locale_to_utf8 (tmpl, -1, NULL, NULL, error);
1998   gchar *utf8_name_used;
1999   gint retval;
2000
2001   if (utf8_tmpl == NULL)
2002     return -1;
2003
2004   retval = g_file_open_tmp_utf8 (utf8_tmpl, &utf8_name_used, error);
2005
2006   if (retval == -1)
2007     return -1;
2008
2009   if (name_used)
2010     *name_used = g_locale_from_utf8 (utf8_name_used, -1, NULL, NULL, NULL);
2011
2012   g_free (utf8_name_used);
2013
2014   return retval;
2015 }
2016
2017 #endif
2018
2019 #define __G_FILEUTILS_C__
2020 #include "galiasdef.c"