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 <io.h>
  41 #ifndef F_OK
  42 #define F_OK 0
  43 #define X_OK 1
  44 #define W_OK 2
  45 #define R_OK 4
  46 #endif /* !F_OK */
  47
  48 #ifndef S_ISREG
  49 #define S_ISREG(mode) ((mode)&_S_IFREG)
  50 #endif
  51
  52 #ifndef S_ISDIR
  53 #define S_ISDIR(mode) ((mode)&_S_IFDIR)
  54 #endif
  55
  56 #endif /* G_OS_WIN32 */
  57
  58 #ifndef S_ISLNK
  59 #define S_ISLNK(x) 0
  60 #endif
  61
  62 #ifndef O_BINARY
  63 #define O_BINARY 0
  64 #endif
  65
  66 #include "glibintl.h"
  67
  68 /**
  69  * g_file_test:
  70  * @filename: a filename to test
  71  * @test: bitfield of #GFileTest flags
  72  *
  73  * Returns %TRUE if any of the tests in the bitfield @test are
  74  * %TRUE. For example, <literal>(G_FILE_TEST_EXISTS |
  75  * G_FILE_TEST_IS_DIR)</literal> will return %TRUE if the file exists;
  76  * the check whether it's a directory doesn't matter since the existence
  77  * test is %TRUE. With the current set of available tests, there's no point
  78  * passing in more than one test at a time.
  79  *
  80  * Apart from %G_FILE_TEST_IS_SYMLINK all tests follow symbolic links,
  81  * so for a symbolic link to a regular file g_file_test() will return
  82  * %TRUE for both %G_FILE_TEST_IS_SYMLINK and %G_FILE_TEST_IS_REGULAR.
  83  *
  84  * Note, that for a dangling symbolic link g_file_test() will return
  85  * %TRUE for %G_FILE_TEST_IS_SYMLINK and %FALSE for all other flags.
  86  *
  87  * You should never use g_file_test() to test whether it is safe
  88  * to perform an operaton, because there is always the possibility
  89  * of the condition changing before you actually perform the operation.
  90  * For example, you might think you could use %G_FILE_TEST_IS_SYMLINK
  91  * to know whether it is is safe to write to a file without being
  92  * tricked into writing into a different location. It doesn't work!
  93  *
  94  * <informalexample><programlisting>
  95  * /&ast; DON'T DO THIS &ast;/
  96  *  if (!g_file_test (filename, G_FILE_TEST_IS_SYMLINK)) {
  97  *    fd = open (filename, O_WRONLY);
  98  *    /&ast; write to fd &ast;/
  99  *  }
 100  * </programlisting></informalexample>
 101  *
 102  * Another thing to note is that %G_FILE_TEST_EXISTS and
 103  * %G_FILE_TEST_IS_EXECUTABLE are implemented using the access()
 104  * system call. This usually doesn't matter, but if your program
 105  * is setuid or setgid it means that these tests will give you
 106  * the answer for the real user ID and group ID , rather than the
 107  * effective user ID and group ID.
 108  *
 109  * Return value: whether a test was %TRUE
 110  **/
 111 gboolean
 112 g_file_test (const gchar *filename,
 113              GFileTest    test)
 114 {
 115   if ((test & G_FILE_TEST_EXISTS) && (access (filename, F_OK) == 0))
 116     return TRUE;
 117
 118   if ((test & G_FILE_TEST_IS_EXECUTABLE) && (access (filename, X_OK) == 0))
 119     {
 120 #ifndef G_OS_WIN32
 121       if (getuid () != 0)
 122 #endif
 123         return TRUE;
 124
 125       /* For root, on some POSIX systems, access (filename, X_OK)
 126        * will succeed even if no executable bits are set on the
 127        * file. We fall through to a stat test to avoid that.
 128        */
 129     }
 130   else
 131     test &= ~G_FILE_TEST_IS_EXECUTABLE;
 132
 133   if (test & G_FILE_TEST_IS_SYMLINK)
 134     {
 135 #ifdef G_OS_WIN32
 136       /* no sym links on win32, no lstat in msvcrt */
 137 #else
 138       struct stat s;
 139
 140       if ((lstat (filename, &s) == 0) && S_ISLNK (s.st_mode))
 141         return TRUE;
 142 #endif
 143     }
 144
 145   if (test & (G_FILE_TEST_IS_REGULAR |
 146               G_FILE_TEST_IS_DIR |
 147               G_FILE_TEST_IS_EXECUTABLE))
 148     {
 149       struct stat s;
 150
 151       if (stat (filename, &s) == 0)
 152         {
 153           if ((test & G_FILE_TEST_IS_REGULAR) && S_ISREG (s.st_mode))
 154             return TRUE;
 155
 156           if ((test & G_FILE_TEST_IS_DIR) && S_ISDIR (s.st_mode))
 157             return TRUE;
 158
 159           /* The extra test for root when access (file, X_OK) succeeds.
 160            */
 161           if ((test & G_FILE_TEST_IS_EXECUTABLE) &&
 162               ((s.st_mode & S_IXOTH) ||
 163                (s.st_mode & S_IXUSR) ||
 164                (s.st_mode & S_IXGRP)))
 165             return TRUE;
 166
 167         }
 168     }
 169
 170   return FALSE;
 171 }
 172
 173 GQuark
 174 g_file_error_quark (void)
 175 {
 176   static GQuark q = 0;
 177   if (q == 0)
 178     q = g_quark_from_static_string ("g-file-error-quark");
 179
 180   return q;
 181 }
 182
 183 /**
 184  * g_file_error_from_errno:
 185  * @err_no: an "errno" value
 186  *
 187  * Gets a #GFileError constant based on the passed-in @errno.
 188  * For example, if you pass in %EEXIST this function returns
 189  * #G_FILE_ERROR_EXIST. Unlike @errno values, you can portably
 190  * assume that all #GFileError values will exist.
 191  *
 192  * Normally a #GFileError value goes into a #GError returned
 193  * from a function that manipulates files. So you would use
 194  * g_file_error_from_errno() when constructing a #GError.
 195  *
 196  * Return value: #GFileError corresponding to the given @errno
 197  **/
 198 GFileError
 199 g_file_error_from_errno (gint err_no)
 200 {
 201   switch (err_no)
 202     {
 203 #ifdef EEXIST
 204     case EEXIST:
 205       return G_FILE_ERROR_EXIST;
 206       break;
 207 #endif
 208
 209 #ifdef EISDIR
 210     case EISDIR:
 211       return G_FILE_ERROR_ISDIR;
 212       break;
 213 #endif
 214
 215 #ifdef EACCES
 216     case EACCES:
 217       return G_FILE_ERROR_ACCES;
 218       break;
 219 #endif
 220
 221 #ifdef ENAMETOOLONG
 222     case ENAMETOOLONG:
 223       return G_FILE_ERROR_NAMETOOLONG;
 224       break;
 225 #endif
 226
 227 #ifdef ENOENT
 228     case ENOENT:
 229       return G_FILE_ERROR_NOENT;
 230       break;
 231 #endif
 232
 233 #ifdef ENOTDIR
 234     case ENOTDIR:
 235       return G_FILE_ERROR_NOTDIR;
 236       break;
 237 #endif
 238
 239 #ifdef ENXIO
 240     case ENXIO:
 241       return G_FILE_ERROR_NXIO;
 242       break;
 243 #endif
 244
 245 #ifdef ENODEV
 246     case ENODEV:
 247       return G_FILE_ERROR_NODEV;
 248       break;
 249 #endif
 250
 251 #ifdef EROFS
 252     case EROFS:
 253       return G_FILE_ERROR_ROFS;
 254       break;
 255 #endif
 256
 257 #ifdef ETXTBSY
 258     case ETXTBSY:
 259       return G_FILE_ERROR_TXTBSY;
 260       break;
 261 #endif
 262
 263 #ifdef EFAULT
 264     case EFAULT:
 265       return G_FILE_ERROR_FAULT;
 266       break;
 267 #endif
 268
 269 #ifdef ELOOP
 270     case ELOOP:
 271       return G_FILE_ERROR_LOOP;
 272       break;
 273 #endif
 274
 275 #ifdef ENOSPC
 276     case ENOSPC:
 277       return G_FILE_ERROR_NOSPC;
 278       break;
 279 #endif
 280
 281 #ifdef ENOMEM
 282     case ENOMEM:
 283       return G_FILE_ERROR_NOMEM;
 284       break;
 285 #endif
 286
 287 #ifdef EMFILE
 288     case EMFILE:
 289       return G_FILE_ERROR_MFILE;
 290       break;
 291 #endif
 292
 293 #ifdef ENFILE
 294     case ENFILE:
 295       return G_FILE_ERROR_NFILE;
 296       break;
 297 #endif
 298
 299 #ifdef EBADF
 300     case EBADF:
 301       return G_FILE_ERROR_BADF;
 302       break;
 303 #endif
 304
 305 #ifdef EINVAL
 306     case EINVAL:
 307       return G_FILE_ERROR_INVAL;
 308       break;
 309 #endif
 310
 311 #ifdef EPIPE
 312     case EPIPE:
 313       return G_FILE_ERROR_PIPE;
 314       break;
 315 #endif
 316
 317 #ifdef EAGAIN
 318     case EAGAIN:
 319       return G_FILE_ERROR_AGAIN;
 320       break;
 321 #endif
 322
 323 #ifdef EINTR
 324     case EINTR:
 325       return G_FILE_ERROR_INTR;
 326       break;
 327 #endif
 328
 329 #ifdef EIO
 330     case EIO:
 331       return G_FILE_ERROR_IO;
 332       break;
 333 #endif
 334
 335 #ifdef EPERM
 336     case EPERM:
 337       return G_FILE_ERROR_PERM;
 338       break;
 339 #endif
 340
 341     default:
 342       return G_FILE_ERROR_FAILED;
 343       break;
 344     }
 345 }
 346
 347 static gboolean
 348 get_contents_stdio (const gchar *filename,
 349                     FILE        *f,
 350                     gchar      **contents,
 351                     gsize       *length,
 352                     GError     **error)
 353 {
 354   gchar buf[2048];
 355   size_t bytes;
 356   char *str;
 357   size_t total_bytes;
 358   size_t total_allocated;
 359
 360   g_assert (f != NULL);
 361
 362 #define STARTING_ALLOC 64
 363
 364   total_bytes = 0;
 365   total_allocated = STARTING_ALLOC;
 366   str = g_malloc (STARTING_ALLOC);
 367
 368   while (!feof (f))
 369     {
 370       bytes = fread (buf, 1, 2048, f);
 371
 372       while ((total_bytes + bytes + 1) > total_allocated)
 373         {
 374           total_allocated *= 2;
 375           str = g_try_realloc (str, total_allocated);
 376
 377           if (str == NULL)
 378             {
 379               g_set_error (error,
 380                            G_FILE_ERROR,
 381                            G_FILE_ERROR_NOMEM,
 382                            _("Could not allocate %lu bytes to read file \"%s\""),
 383                            (gulong) total_allocated, filename);
 384               goto error;
 385             }
 386         }
 387
 388       if (ferror (f))
 389         {
 390           g_set_error (error,
 391                        G_FILE_ERROR,
 392                        g_file_error_from_errno (errno),
 393                        _("Error reading file '%s': %s"),
 394                        filename, g_strerror (errno));
 395
 396           goto error;
 397         }
 398
 399       memcpy (str + total_bytes, buf, bytes);
 400       total_bytes += bytes;
 401     }
 402
 403   fclose (f);
 404
 405   str[total_bytes] = '\0';
 406
 407   if (length)
 408     *length = total_bytes;
 409
 410   *contents = str;
 411
 412   return TRUE;
 413
 414  error:
 415
 416   g_free (str);
 417   fclose (f);
 418
 419   return FALSE;
 420 }
 421
 422 #ifndef G_OS_WIN32
 423
 424 static gboolean
 425 get_contents_regfile (const gchar *filename,
 426                       struct stat *stat_buf,
 427                       gint         fd,
 428                       gchar      **contents,
 429                       gsize       *length,
 430                       GError     **error)
 431 {
 432   gchar *buf;
 433   size_t bytes_read;
 434   size_t size;
 435   size_t alloc_size;
 436
 437   size = stat_buf->st_size;
 438
 439   alloc_size = size + 1;
 440   buf = g_try_malloc (alloc_size);
 441
 442   if (buf == NULL)
 443     {
 444       g_set_error (error,
 445                    G_FILE_ERROR,
 446                    G_FILE_ERROR_NOMEM,
 447                    _("Could not allocate %lu bytes to read file \"%s\""),
 448                    (gulong) alloc_size, filename);
 449
 450       goto error;
 451     }
 452
 453   bytes_read = 0;
 454   while (bytes_read < size)
 455     {
 456       gssize rc;
 457
 458       rc = read (fd, buf + bytes_read, size - bytes_read);
 459
 460       if (rc < 0)
 461         {
 462           if (errno != EINTR)
 463             {
 464               g_free (buf);
 465
 466               g_set_error (error,
 467                            G_FILE_ERROR,
 468                            g_file_error_from_errno (errno),
 469                            _("Failed to read from file '%s': %s"),
 470                            filename, g_strerror (errno));
 471
 472               goto error;
 473             }
 474         }
 475       else if (rc == 0)
 476         break;
 477       else
 478         bytes_read += rc;
 479     }
 480
 481   buf[bytes_read] = '\0';
 482
 483   if (length)
 484     *length = bytes_read;
 485
 486   *contents = buf;
 487
 488   close (fd);
 489
 490   return TRUE;
 491
 492  error:
 493
 494   close (fd);
 495
 496   return FALSE;
 497 }
 498
 499 static gboolean
 500 get_contents_posix (const gchar *filename,
 501                     gchar      **contents,
 502                     gsize       *length,
 503                     GError     **error)
 504 {
 505   struct stat stat_buf;
 506   gint fd;
 507
 508   /* O_BINARY useful on Cygwin */
 509   fd = open (filename, O_RDONLY|O_BINARY);
 510
 511   if (fd < 0)
 512     {
 513       g_set_error (error,
 514                    G_FILE_ERROR,
 515                    g_file_error_from_errno (errno),
 516                    _("Failed to open file '%s': %s"),
 517                    filename, g_strerror (errno));
 518
 519       return FALSE;
 520     }
 521
 522   /* I don't think this will ever fail, aside from ENOMEM, but. */
 523   if (fstat (fd, &stat_buf) < 0)
 524     {
 525       close (fd);
 526
 527       g_set_error (error,
 528                    G_FILE_ERROR,
 529                    g_file_error_from_errno (errno),
 530                    _("Failed to get attributes of file '%s': fstat() failed: %s"),
 531                    filename, g_strerror (errno));
 532
 533       return FALSE;
 534     }
 535
 536   if (stat_buf.st_size > 0 && S_ISREG (stat_buf.st_mode))
 537     {
 538       return get_contents_regfile (filename,
 539                                    &stat_buf,
 540                                    fd,
 541                                    contents,
 542                                    length,
 543                                    error);
 544     }
 545   else
 546     {
 547       FILE *f;
 548
 549       f = fdopen (fd, "r");
 550
 551       if (f == NULL)
 552         {
 553           g_set_error (error,
 554                        G_FILE_ERROR,
 555                        g_file_error_from_errno (errno),
 556                        _("Failed to open file '%s': fdopen() failed: %s"),
 557                        filename, g_strerror (errno));
 558
 559           return FALSE;
 560         }
 561
 562       return get_contents_stdio (filename, f, contents, length, error);
 563     }
 564 }
 565
 566 #else  /* G_OS_WIN32 */
 567
 568 static gboolean
 569 get_contents_win32 (const gchar *filename,
 570                     gchar      **contents,
 571                     gsize       *length,
 572                     GError     **error)
 573 {
 574   FILE *f;
 575
 576   /* I guess you want binary mode; maybe you want text sometimes? */
 577   f = fopen (filename, "rb");
 578
 579   if (f == NULL)
 580     {
 581       g_set_error (error,
 582                    G_FILE_ERROR,
 583                    g_file_error_from_errno (errno),
 584                    _("Failed to open file '%s': %s"),
 585                    filename, g_strerror (errno));
 586
 587       return FALSE;
 588     }
 589
 590   return get_contents_stdio (filename, f, contents, length, error);
 591 }
 592
 593 #endif
 594
 595 /**
 596  * g_file_get_contents:
 597  * @filename: a file to read contents from
 598  * @contents: location to store an allocated string
 599  * @length: location to store length in bytes of the contents
 600  * @error: return location for a #GError
 601  *
 602  * Reads an entire file into allocated memory, with good error
 603  * checking. If @error is set, %FALSE is returned, and @contents is set
 604  * to %NULL. If %TRUE is returned, @error will not be set, and @contents
 605  * will be set to the file contents.  The string stored in @contents
 606  * will be nul-terminated, so for text files you can pass %NULL for the
 607  * @length argument.  The error domain is #G_FILE_ERROR. Possible
 608  * error codes are those in the #GFileError enumeration.
 609  *
 610  * Return value: %TRUE on success, %FALSE if error is set
 611  **/
 612 gboolean
 613 g_file_get_contents (const gchar *filename,
 614                      gchar      **contents,
 615                      gsize       *length,
 616                      GError     **error)
 617 {
 618   g_return_val_if_fail (filename != NULL, FALSE);
 619   g_return_val_if_fail (contents != NULL, FALSE);
 620
 621   *contents = NULL;
 622   if (length)
 623     *length = 0;
 624
 625 #ifdef G_OS_WIN32
 626   return get_contents_win32 (filename, contents, length, error);
 627 #else
 628   return get_contents_posix (filename, contents, length, error);
 629 #endif
 630 }
 631
 632 /*
 633  * mkstemp() implementation is from the GNU C library.
 634  * Copyright (C) 1991,92,93,94,95,96,97,98,99 Free Software Foundation, Inc.
 635  */
 636 /**
 637  * g_mkstemp:
 638  * @tmpl: template filename
 639  *
 640  * Opens a temporary file. See the <function>mkstemp()</function> documentation
 641  * on most UNIX-like systems. This is a portability wrapper, which simply calls
 642  * <function>mkstemp()</function> on systems that have it, and implements
 643  * it in GLib otherwise.
 644  *
 645  * The parameter is a string that should match the rules for
 646  * <function>mkstemp()</function>, i.e. end in "XXXXXX". The X string will
 647  * be modified to form the name of a file that didn't exist.
 648  *
 649  * Return value: A file handle (as from <function>open()</function>) to the file
 650  * opened for reading and writing. The file is opened in binary mode
 651  * on platforms where there is a difference. The file handle should be
 652  * closed with <function>close()</function>. In case of errors, -1 is returned.
 653  */
 654 int
 655 g_mkstemp (char *tmpl)
 656 {
 657 #ifdef HAVE_MKSTEMP
 658   return mkstemp (tmpl);
 659 #else
 660   int len;
 661   char *XXXXXX;
 662   int count, fd;
 663   static const char letters[] =
 664     "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
 665   static const int NLETTERS = sizeof (letters) - 1;
 666   glong value;
 667   GTimeVal tv;
 668   static int counter = 0;
 669
 670   len = strlen (tmpl);
 671   if (len < 6 || strcmp (&tmpl[len - 6], "XXXXXX"))
 672     return -1;
 673
 674   /* This is where the Xs start.  */
 675   XXXXXX = &tmpl[len - 6];
 676
 677   /* Get some more or less random data.  */
 678   g_get_current_time (&tv);
 679   value = (tv.tv_usec ^ tv.tv_sec) + counter++;
 680
 681   for (count = 0; count < 100; value += 7777, ++count)
 682     {
 683       glong v = value;
 684
 685       /* Fill in the random bits.  */
 686       XXXXXX[0] = letters[v % NLETTERS];
 687       v /= NLETTERS;
 688       XXXXXX[1] = letters[v % NLETTERS];
 689       v /= NLETTERS;
 690       XXXXXX[2] = letters[v % NLETTERS];
 691       v /= NLETTERS;
 692       XXXXXX[3] = letters[v % NLETTERS];
 693       v /= NLETTERS;
 694       XXXXXX[4] = letters[v % NLETTERS];
 695       v /= NLETTERS;
 696       XXXXXX[5] = letters[v % NLETTERS];
 697
 698       fd = open (tmpl, O_RDWR | O_CREAT | O_EXCL | O_BINARY, 0600);
 699
 700       if (fd >= 0)
 701         return fd;
 702       else if (errno != EEXIST)
 703         /* Any other error will apply also to other names we might
 704          *  try, and there are 2^32 or so of them, so give up now.
 705          */
 706         return -1;
 707     }
 708
 709   /* We got out of the loop because we ran out of combinations to try.  */
 710   return -1;
 711 #endif
 712 }
 713
 714 /**
 715  * g_file_open_tmp:
 716  * @tmpl: Template for file name, as in g_mkstemp(), basename only
 717  * @name_used: location to store actual name used
 718  * @error: return location for a #GError
 719  *
 720  * Opens a file for writing in the preferred directory for temporary
 721  * files (as returned by g_get_tmp_dir()).
 722  *
 723  * @tmpl should be a string ending with six 'X' characters, as the
 724  * parameter to g_mkstemp() (or <function>mkstemp()</function>).
 725  * However, unlike these functions, the template should only be a
 726  * basename, no directory components are allowed. If template is %NULL,
 727  * a default template is used.
 728  *
 729  * Note that in contrast to g_mkstemp() (and <function>mkstemp()</function>)
 730  * @tmpl is not modified, and might thus be a read-only literal string.
 731  *
 732  * The actual name used is returned in @name_used if non-%NULL. This
 733  * string should be freed with g_free() when not needed any longer.
 734  *
 735  * Return value: A file handle (as from <function>open()</function>) to
 736  * the file opened for reading and writing. The file is opened in binary
 737  * mode on platforms where there is a difference. The file handle should be
 738  * closed with <function>close()</function>. In case of errors, -1 is returned
 739  * and @error will be set.
 740  **/
 741 int
 742 g_file_open_tmp (const char *tmpl,
 743                  char      **name_used,
 744                  GError    **error)
 745 {
 746   int retval;
 747   const char *tmpdir;
 748   char *sep;
 749   char *fulltemplate;
 750
 751   if (tmpl == NULL)
 752     tmpl = ".XXXXXX";
 753
 754   if (strchr (tmpl, G_DIR_SEPARATOR)
 755 #ifdef G_OS_WIN32
 756       || strchr (tmpl, '/')
 757 #endif
 758                                     )
 759     {
 760       g_set_error (error,
 761                    G_FILE_ERROR,
 762                    G_FILE_ERROR_FAILED,
 763                    _("Template '%s' invalid, should not contain a '%s'"),
 764                    tmpl, G_DIR_SEPARATOR_S);
 765
 766       return -1;
 767     }
 768
 769   if (strlen (tmpl) < 6 ||
 770       strcmp (tmpl + strlen (tmpl) - 6, "XXXXXX") != 0)
 771     {
 772       g_set_error (error,
 773                    G_FILE_ERROR,
 774                    G_FILE_ERROR_FAILED,
 775                    _("Template '%s' doesn't end with XXXXXX"),
 776                    tmpl);
 777       return -1;
 778     }
 779
 780   tmpdir = g_get_tmp_dir ();
 781
 782   if (tmpdir [strlen (tmpdir) - 1] == G_DIR_SEPARATOR)
 783     sep = "";
 784   else
 785     sep = G_DIR_SEPARATOR_S;
 786
 787   fulltemplate = g_strconcat (tmpdir, sep, tmpl, NULL);
 788
 789   retval = g_mkstemp (fulltemplate);
 790
 791   if (retval == -1)
 792     {
 793       g_set_error (error,
 794                    G_FILE_ERROR,
 795                    g_file_error_from_errno (errno),
 796                    _("Failed to create file '%s': %s"),
 797                    fulltemplate, g_strerror (errno));
 798       g_free (fulltemplate);
 799       return -1;
 800     }
 801
 802   if (name_used)
 803     *name_used = fulltemplate;
 804   else
 805     g_free (fulltemplate);
 806
 807   return retval;
 808 }
 809
 810 static gchar *
 811 g_build_pathv (const gchar *separator,
 812                const gchar *first_element,
 813                va_list      args)
 814 {
 815   GString *result;
 816   gint separator_len = strlen (separator);
 817   gboolean is_first = TRUE;
 818   gboolean have_leading = FALSE;
 819   const gchar *single_element = NULL;
 820   const gchar *next_element;
 821   const gchar *last_trailing = NULL;
 822
 823   result = g_string_new (NULL);
 824
 825   next_element = first_element;
 826
 827   while (TRUE)
 828     {
 829       const gchar *element;
 830       const gchar *start;
 831       const gchar *end;
 832
 833       if (next_element)
 834         {
 835           element = next_element;
 836           next_element = va_arg (args, gchar *);
 837         }
 838       else
 839         break;
 840
 841       /* Ignore empty elements */
 842       if (!*element)
 843         continue;
 844
 845       start = element;
 846
 847       if (separator_len)
 848         {
 849           while (start &&
 850                  strncmp (start, separator, separator_len) == 0)
 851             start += separator_len;
 852         }
 853
 854       end = start + strlen (start);
 855
 856       if (separator_len)
 857         {
 858           while (end >= start + separator_len &&
 859                  strncmp (end - separator_len, separator, separator_len) == 0)
 860             end -= separator_len;
 861
 862           last_trailing = end;
 863           while (last_trailing >= element + separator_len &&
 864                  strncmp (last_trailing - separator_len, separator, separator_len) == 0)
 865             last_trailing -= separator_len;
 866
 867           if (!have_leading)
 868             {
 869               /* If the leading and trailing separator strings are in the
 870                * same element and overlap, the result is exactly that element
 871                */
 872               if (last_trailing <= start)
 873                 single_element = element;
 874
 875               g_string_append_len (result, element, start - element);
 876               have_leading = TRUE;
 877             }
 878           else
 879             single_element = NULL;
 880         }
 881
 882       if (end == start)
 883         continue;
 884
 885       if (!is_first)
 886         g_string_append (result, separator);
 887
 888       g_string_append_len (result, start, end - start);
 889       is_first = FALSE;
 890     }
 891
 892   if (single_element)
 893     {
 894       g_string_free (result, TRUE);
 895       return g_strdup (single_element);
 896     }
 897   else
 898     {
 899       if (last_trailing)
 900         g_string_append (result, last_trailing);
 901
 902       return g_string_free (result, FALSE);
 903     }
 904 }
 905
 906 /**
 907  * g_build_path:
 908  * @separator: a string used to separator the elements of the path.
 909  * @first_element: the first element in the path
 910  * @Varargs: remaining elements in path, terminated by %NULL
 911  *
 912  * Creates a path from a series of elements using @separator as the
 913  * separator between elements. At the boundary between two elements,
 914  * any trailing occurrences of separator in the first element, or
 915  * leading occurrences of separator in the second element are removed
 916  * and exactly one copy of the separator is inserted.
 917  *
 918  * Empty elements are ignored.
 919  *
 920  * The number of leading copies of the separator on the result is
 921  * the same as the number of leading copies of the separator on
 922  * the first non-empty element.
 923  *
 924  * The number of trailing copies of the separator on the result is
 925  * the same as the number of trailing copies of the separator on
 926  * the last non-empty element. (Determination of the number of
 927  * trailing copies is done without stripping leading copies, so
 928  * if the separator is <literal>ABA</literal>, <literal>ABABA</literal>
 929  * has 1 trailing copy.)
 930  *
 931  * However, if there is only a single non-empty element, and there
 932  * are no characters in that element not part of the leading or
 933  * trailing separators, then the result is exactly the original value
 934  * of that element.
 935  *
 936  * Other than for determination of the number of leading and trailing
 937  * copies of the separator, elements consisting only of copies
 938  * of the separator are ignored.
 939  *
 940  * Return value: a newly-allocated string that must be freed with g_free().
 941  **/
 942 gchar *
 943 g_build_path (const gchar *separator,
 944               const gchar *first_element,
 945               ...)
 946 {
 947   gchar *str;
 948   va_list args;
 949
 950   g_return_val_if_fail (separator != NULL, NULL);
 951
 952   va_start (args, first_element);
 953   str = g_build_pathv (separator, first_element, args);
 954   va_end (args);
 955
 956   return str;
 957 }
 958
 959 /**
 960  * g_build_filename:
 961  * @first_element: the first element in the path
 962  * @Varargs: remaining elements in path, terminated by %NULL
 963  *
 964  * Creates a filename from a series of elements using the correct
 965  * separator for filenames. This function behaves identically
 966  * to <literal>g_build_path (G_DIR_SEPARATOR_S, first_element, ....)</literal>.
 967  *
 968  * No attempt is made to force the resulting filename to be an absolute
 969  * path. If the first element is a relative path, the result will
 970  * be a relative path.
 971  *
 972  * Return value: a newly-allocated string that must be freed with g_free().
 973  **/
 974 gchar *
 975 g_build_filename (const gchar *first_element,
 976                   ...)
 977 {
 978   gchar *str;
 979   va_list args;
 980
 981   va_start (args, first_element);
 982   str = g_build_pathv (G_DIR_SEPARATOR_S, first_element, args);
 983   va_end (args);
 984
 985   return str;
 986 }