1 /* gfileutils.c - File utility functions
3 * Copyright 2000 Red Hat, Inc.
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.
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.
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.
22 #include "glibconfig.h"
30 #include <sys/types.h>
41 #endif /* G_OS_WIN32 */
51 #include "gfileutils.h"
56 #ifdef HAVE_LINUX_MAGIC_H /* for btrfs check */
57 #include <linux/magic.h>
64 * @title: File Utilities
65 * @short_description: various file-related functions
67 * There is a group of functions which wrap the common POSIX functions
68 * dealing with filenames (g_open(), g_rename(), g_mkdir(), g_stat(),
69 * g_unlink(), g_remove(), g_fopen(), g_freopen()). The point of these
70 * wrappers is to make it possible to handle file names with any Unicode
71 * characters in them on Windows without having to use ifdefs and the
72 * wide character API in the application code.
74 * The pathname argument should be in the GLib file name encoding.
75 * On POSIX this is the actual on-disk encoding which might correspond
76 * to the locale settings of the process (or the
77 * <envar>G_FILENAME_ENCODING</envar> environment variable), or not.
79 * On Windows the GLib file name encoding is UTF-8. Note that the
80 * Microsoft C library does not use UTF-8, but has separate APIs for
81 * current system code page and wide characters (UTF-16). The GLib
82 * wrappers call the wide character API if present (on modern Windows
83 * systems), otherwise convert to/from the system code page.
85 * Another group of functions allows to open and read directories
86 * in the GLib file name encoding. These are g_dir_open(),
87 * g_dir_read_name(), g_dir_rewind(), g_dir_close().
92 * @G_FILE_ERROR_EXIST: Operation not permitted; only the owner of
93 * the file (or other resource) or processes with special privileges
94 * can perform the operation.
95 * @G_FILE_ERROR_ISDIR: File is a directory; you cannot open a directory
96 * for writing, or create or remove hard links to it.
97 * @G_FILE_ERROR_ACCES: Permission denied; the file permissions do not
98 * allow the attempted operation.
99 * @G_FILE_ERROR_NAMETOOLONG: Filename too long.
100 * @G_FILE_ERROR_NOENT: No such file or directory. This is a "file
101 * doesn't exist" error for ordinary files that are referenced in
102 * contexts where they are expected to already exist.
103 * @G_FILE_ERROR_NOTDIR: A file that isn't a directory was specified when
104 * a directory is required.
105 * @G_FILE_ERROR_NXIO: No such device or address. The system tried to
106 * use the device represented by a file you specified, and it
107 * couldn't find the device. This can mean that the device file was
108 * installed incorrectly, or that the physical device is missing or
109 * not correctly attached to the computer.
110 * @G_FILE_ERROR_NODEV: The underlying file system of the specified file
111 * does not support memory mapping.
112 * @G_FILE_ERROR_ROFS: The directory containing the new link can't be
113 * modified because it's on a read-only file system.
114 * @G_FILE_ERROR_TXTBSY: Text file busy.
115 * @G_FILE_ERROR_FAULT: You passed in a pointer to bad memory.
116 * (GLib won't reliably return this, don't pass in pointers to bad
118 * @G_FILE_ERROR_LOOP: Too many levels of symbolic links were encountered
119 * in looking up a file name. This often indicates a cycle of symbolic
121 * @G_FILE_ERROR_NOSPC: No space left on device; write operation on a
122 * file failed because the disk is full.
123 * @G_FILE_ERROR_NOMEM: No memory available. The system cannot allocate
124 * more virtual memory because its capacity is full.
125 * @G_FILE_ERROR_MFILE: The current process has too many files open and
126 * can't open any more. Duplicate descriptors do count toward this
128 * @G_FILE_ERROR_NFILE: There are too many distinct file openings in the
130 * @G_FILE_ERROR_BADF: Bad file descriptor; for example, I/O on a
131 * descriptor that has been closed or reading from a descriptor open
132 * only for writing (or vice versa).
133 * @G_FILE_ERROR_INVAL: Invalid argument. This is used to indicate
134 * various kinds of problems with passing the wrong argument to a
136 * @G_FILE_ERROR_PIPE: Broken pipe; there is no process reading from the
137 * other end of a pipe. Every library function that returns this
138 * error code also generates a 'SIGPIPE' signal; this signal
139 * terminates the program if not handled or blocked. Thus, your
140 * program will never actually see this code unless it has handled
141 * or blocked 'SIGPIPE'.
142 * @G_FILE_ERROR_AGAIN: Resource temporarily unavailable; the call might
143 * work if you try again later.
144 * @G_FILE_ERROR_INTR: Interrupted function call; an asynchronous signal
145 * occurred and prevented completion of the call. When this
146 * happens, you should try the call again.
147 * @G_FILE_ERROR_IO: Input/output error; usually used for physical read
148 * or write errors. i.e. the disk or other physical device hardware
149 * is returning errors.
150 * @G_FILE_ERROR_PERM: Operation not permitted; only the owner of the
151 * file (or other resource) or processes with special privileges can
152 * perform the operation.
153 * @G_FILE_ERROR_NOSYS: Function not implemented; this indicates that
154 * the system is missing some functionality.
155 * @G_FILE_ERROR_FAILED: Does not correspond to a UNIX error code; this
156 * is the standard "failed for unspecified reason" error code present
157 * in all #GError error code enumerations. Returned if no specific
160 * Values corresponding to @errno codes returned from file operations
161 * on UNIX. Unlike @errno codes, GFileError values are available on
162 * all systems, even Windows. The exact meaning of each code depends
163 * on what sort of file operation you were performing; the UNIX
164 * documentation gives more details. The following error code descriptions
165 * come from the GNU C Library manual, and are under the copyright
168 * It's not very portable to make detailed assumptions about exactly
169 * which errors will be returned from a given operation. Some errors
170 * don't occur on some systems, etc., sometimes there are subtle
171 * differences in when a system will report a given error, etc.
177 * Error domain for file operations. Errors in this domain will
178 * be from the #GFileError enumeration. See #GError for information
184 * @G_FILE_TEST_IS_REGULAR: %TRUE if the file is a regular file
185 * (not a directory). Note that this test will also return %TRUE
186 * if the tested file is a symlink to a regular file.
187 * @G_FILE_TEST_IS_SYMLINK: %TRUE if the file is a symlink.
188 * @G_FILE_TEST_IS_DIR: %TRUE if the file is a directory.
189 * @G_FILE_TEST_IS_EXECUTABLE: %TRUE if the file is executable.
190 * @G_FILE_TEST_EXISTS: %TRUE if the file exists. It may or may not
193 * A test to perform on a file using g_file_test().
197 * g_mkdir_with_parents:
198 * @pathname: a pathname in the GLib file name encoding
199 * @mode: permissions to use for newly created directories
201 * Create a directory if it doesn't already exist. Create intermediate
202 * parent directories as needed, too.
204 * Returns: 0 if the directory already exists, or was successfully
205 * created. Returns -1 if an error occurred, with errno set.
210 g_mkdir_with_parents (const gchar *pathname,
215 if (pathname == NULL || *pathname == '\0')
221 fn = g_strdup (pathname);
223 if (g_path_is_absolute (fn))
224 p = (gchar *) g_path_skip_root (fn);
230 while (*p && !G_IS_DIR_SEPARATOR (*p))
238 if (!g_file_test (fn, G_FILE_TEST_EXISTS))
240 if (g_mkdir (fn, mode) == -1 && errno != EEXIST)
242 int errno_save = errno;
248 else if (!g_file_test (fn, G_FILE_TEST_IS_DIR))
256 *p++ = G_DIR_SEPARATOR;
257 while (*p && G_IS_DIR_SEPARATOR (*p))
270 * @filename: a filename to test in the GLib file name encoding
271 * @test: bitfield of #GFileTest flags
273 * Returns %TRUE if any of the tests in the bitfield @test are
274 * %TRUE. For example, <literal>(G_FILE_TEST_EXISTS |
275 * G_FILE_TEST_IS_DIR)</literal> will return %TRUE if the file exists;
276 * the check whether it's a directory doesn't matter since the existence
277 * test is %TRUE. With the current set of available tests, there's no point
278 * passing in more than one test at a time.
280 * Apart from %G_FILE_TEST_IS_SYMLINK all tests follow symbolic links,
281 * so for a symbolic link to a regular file g_file_test() will return
282 * %TRUE for both %G_FILE_TEST_IS_SYMLINK and %G_FILE_TEST_IS_REGULAR.
284 * Note, that for a dangling symbolic link g_file_test() will return
285 * %TRUE for %G_FILE_TEST_IS_SYMLINK and %FALSE for all other flags.
287 * You should never use g_file_test() to test whether it is safe
288 * to perform an operation, because there is always the possibility
289 * of the condition changing before you actually perform the operation.
290 * For example, you might think you could use %G_FILE_TEST_IS_SYMLINK
291 * to know whether it is safe to write to a file without being
292 * tricked into writing into a different location. It doesn't work!
294 * /* DON'T DO THIS */
295 * if (!g_file_test (filename, G_FILE_TEST_IS_SYMLINK))
297 * fd = g_open (filename, O_WRONLY);
298 * /* write to fd */
302 * Another thing to note is that %G_FILE_TEST_EXISTS and
303 * %G_FILE_TEST_IS_EXECUTABLE are implemented using the access()
304 * system call. This usually doesn't matter, but if your program
305 * is setuid or setgid it means that these tests will give you
306 * the answer for the real user ID and group ID, rather than the
307 * effective user ID and group ID.
309 * On Windows, there are no symlinks, so testing for
310 * %G_FILE_TEST_IS_SYMLINK will always return %FALSE. Testing for
311 * %G_FILE_TEST_IS_EXECUTABLE will just check that the file exists and
312 * its name indicates that it is executable, checking for well-known
313 * extensions and those listed in the <envar>PATHEXT</envar> environment variable.
315 * Return value: whether a test was %TRUE
318 g_file_test (const gchar *filename,
322 /* stuff missing in std vc6 api */
323 # ifndef INVALID_FILE_ATTRIBUTES
324 # define INVALID_FILE_ATTRIBUTES -1
326 # ifndef FILE_ATTRIBUTE_DEVICE
327 # define FILE_ATTRIBUTE_DEVICE 64
330 wchar_t *wfilename = g_utf8_to_utf16 (filename, -1, NULL, NULL, NULL);
332 if (wfilename == NULL)
335 attributes = GetFileAttributesW (wfilename);
339 if (attributes == INVALID_FILE_ATTRIBUTES)
342 if (test & G_FILE_TEST_EXISTS)
345 if (test & G_FILE_TEST_IS_REGULAR)
347 if ((attributes & (FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_DEVICE)) == 0)
351 if (test & G_FILE_TEST_IS_DIR)
353 if ((attributes & FILE_ATTRIBUTE_DIRECTORY) != 0)
357 /* "while" so that we can exit this "loop" with a simple "break" */
358 while (test & G_FILE_TEST_IS_EXECUTABLE)
360 const gchar *lastdot = strrchr (filename, '.');
361 const gchar *pathext = NULL, *p;
367 if (_stricmp (lastdot, ".exe") == 0 ||
368 _stricmp (lastdot, ".cmd") == 0 ||
369 _stricmp (lastdot, ".bat") == 0 ||
370 _stricmp (lastdot, ".com") == 0)
373 /* Check if it is one of the types listed in %PATHEXT% */
375 pathext = g_getenv ("PATHEXT");
379 pathext = g_utf8_casefold (pathext, -1);
381 lastdot = g_utf8_casefold (lastdot, -1);
382 extlen = strlen (lastdot);
387 const gchar *q = strchr (p, ';');
390 if (extlen == q - p &&
391 memcmp (lastdot, p, extlen) == 0)
393 g_free ((gchar *) pathext);
394 g_free ((gchar *) lastdot);
403 g_free ((gchar *) pathext);
404 g_free ((gchar *) lastdot);
410 if ((test & G_FILE_TEST_EXISTS) && (access (filename, F_OK) == 0))
413 if ((test & G_FILE_TEST_IS_EXECUTABLE) && (access (filename, X_OK) == 0))
418 /* For root, on some POSIX systems, access (filename, X_OK)
419 * will succeed even if no executable bits are set on the
420 * file. We fall through to a stat test to avoid that.
424 test &= ~G_FILE_TEST_IS_EXECUTABLE;
426 if (test & G_FILE_TEST_IS_SYMLINK)
430 if ((lstat (filename, &s) == 0) && S_ISLNK (s.st_mode))
434 if (test & (G_FILE_TEST_IS_REGULAR |
436 G_FILE_TEST_IS_EXECUTABLE))
440 if (stat (filename, &s) == 0)
442 if ((test & G_FILE_TEST_IS_REGULAR) && S_ISREG (s.st_mode))
445 if ((test & G_FILE_TEST_IS_DIR) && S_ISDIR (s.st_mode))
448 /* The extra test for root when access (file, X_OK) succeeds.
450 if ((test & G_FILE_TEST_IS_EXECUTABLE) &&
451 ((s.st_mode & S_IXOTH) ||
452 (s.st_mode & S_IXUSR) ||
453 (s.st_mode & S_IXGRP)))
462 G_DEFINE_QUARK (g-file-error-quark, g_file_error)
465 * g_file_error_from_errno:
466 * @err_no: an "errno" value
468 * Gets a #GFileError constant based on the passed-in @err_no.
469 * For example, if you pass in <literal>EEXIST</literal> this function returns
470 * #G_FILE_ERROR_EXIST. Unlike <literal>errno</literal> values, you can portably
471 * assume that all #GFileError values will exist.
473 * Normally a #GFileError value goes into a #GError returned
474 * from a function that manipulates files. So you would use
475 * g_file_error_from_errno() when constructing a #GError.
477 * Return value: #GFileError corresponding to the given @errno
480 g_file_error_from_errno (gint err_no)
486 return G_FILE_ERROR_EXIST;
491 return G_FILE_ERROR_ISDIR;
496 return G_FILE_ERROR_ACCES;
501 return G_FILE_ERROR_NAMETOOLONG;
506 return G_FILE_ERROR_NOENT;
511 return G_FILE_ERROR_NOTDIR;
516 return G_FILE_ERROR_NXIO;
521 return G_FILE_ERROR_NODEV;
526 return G_FILE_ERROR_ROFS;
531 return G_FILE_ERROR_TXTBSY;
536 return G_FILE_ERROR_FAULT;
541 return G_FILE_ERROR_LOOP;
546 return G_FILE_ERROR_NOSPC;
551 return G_FILE_ERROR_NOMEM;
556 return G_FILE_ERROR_MFILE;
561 return G_FILE_ERROR_NFILE;
566 return G_FILE_ERROR_BADF;
571 return G_FILE_ERROR_INVAL;
576 return G_FILE_ERROR_PIPE;
581 return G_FILE_ERROR_AGAIN;
586 return G_FILE_ERROR_INTR;
591 return G_FILE_ERROR_IO;
596 return G_FILE_ERROR_PERM;
601 return G_FILE_ERROR_NOSYS;
605 return G_FILE_ERROR_FAILED;
610 get_contents_stdio (const gchar *display_filename,
617 gsize bytes; /* always <= sizeof(buf) */
619 gsize total_bytes = 0;
620 gsize total_allocated = 0;
623 g_assert (f != NULL);
629 bytes = fread (buf, 1, sizeof (buf), f);
632 if (total_bytes > G_MAXSIZE - bytes)
635 /* Possibility of overflow eliminated above. */
636 while (total_bytes + bytes >= total_allocated)
640 if (total_allocated > G_MAXSIZE / 2)
642 total_allocated *= 2;
646 total_allocated = MIN (bytes + 1, sizeof (buf));
649 tmp = g_try_realloc (str, total_allocated);
656 g_dngettext (GETTEXT_PACKAGE, "Could not allocate %lu byte to read file \"%s\"", "Could not allocate %lu bytes to read file \"%s\"", (gulong)total_allocated),
657 (gulong) total_allocated,
670 g_file_error_from_errno (save_errno),
671 _("Error reading file '%s': %s"),
673 g_strerror (save_errno));
678 g_assert (str != NULL);
679 memcpy (str + total_bytes, buf, bytes);
681 total_bytes += bytes;
686 if (total_allocated == 0)
688 str = g_new (gchar, 1);
692 str[total_bytes] = '\0';
695 *length = total_bytes;
705 _("File \"%s\" is too large"),
719 get_contents_regfile (const gchar *display_filename,
720 struct stat *stat_buf,
731 size = stat_buf->st_size;
733 alloc_size = size + 1;
734 buf = g_try_malloc (alloc_size);
741 g_dngettext (GETTEXT_PACKAGE, "Could not allocate %lu byte to read file \"%s\"", "Could not allocate %lu bytes to read file \"%s\"", (gulong)alloc_size),
749 while (bytes_read < size)
753 rc = read (fd, buf + bytes_read, size - bytes_read);
759 int save_errno = errno;
764 g_file_error_from_errno (save_errno),
765 _("Failed to read from file '%s': %s"),
767 g_strerror (save_errno));
778 buf[bytes_read] = '\0';
781 *length = bytes_read;
797 get_contents_posix (const gchar *filename,
802 struct stat stat_buf;
804 gchar *display_filename = g_filename_display_name (filename);
806 /* O_BINARY useful on Cygwin */
807 fd = open (filename, O_RDONLY|O_BINARY);
811 int save_errno = errno;
815 g_file_error_from_errno (save_errno),
816 _("Failed to open file '%s': %s"),
818 g_strerror (save_errno));
819 g_free (display_filename);
824 /* I don't think this will ever fail, aside from ENOMEM, but. */
825 if (fstat (fd, &stat_buf) < 0)
827 int save_errno = errno;
832 g_file_error_from_errno (save_errno),
833 _("Failed to get attributes of file '%s': fstat() failed: %s"),
835 g_strerror (save_errno));
836 g_free (display_filename);
841 if (stat_buf.st_size > 0 && S_ISREG (stat_buf.st_mode))
843 gboolean retval = get_contents_regfile (display_filename,
849 g_free (display_filename);
858 f = fdopen (fd, "r");
862 int save_errno = errno;
866 g_file_error_from_errno (save_errno),
867 _("Failed to open file '%s': fdopen() failed: %s"),
869 g_strerror (save_errno));
870 g_free (display_filename);
875 retval = get_contents_stdio (display_filename, f, contents, length, error);
876 g_free (display_filename);
882 #else /* G_OS_WIN32 */
885 get_contents_win32 (const gchar *filename,
892 gchar *display_filename = g_filename_display_name (filename);
895 f = g_fopen (filename, "rb");
902 g_file_error_from_errno (save_errno),
903 _("Failed to open file '%s': %s"),
905 g_strerror (save_errno));
906 g_free (display_filename);
911 retval = get_contents_stdio (display_filename, f, contents, length, error);
912 g_free (display_filename);
920 * g_file_get_contents:
921 * @filename: (type filename): name of a file to read contents from, in the GLib file name encoding
922 * @contents: (out) (array length=length) (element-type guint8): location to store an allocated string, use g_free() to free
923 * the returned string
924 * @length: (allow-none): location to store length in bytes of the contents, or %NULL
925 * @error: return location for a #GError, or %NULL
927 * Reads an entire file into allocated memory, with good error
930 * If the call was successful, it returns %TRUE and sets @contents to the file
931 * contents and @length to the length of the file contents in bytes. The string
932 * stored in @contents will be nul-terminated, so for text files you can pass
933 * %NULL for the @length argument. If the call was not successful, it returns
934 * %FALSE and sets @error. The error domain is #G_FILE_ERROR. Possible error
935 * codes are those in the #GFileError enumeration. In the error case,
936 * @contents is set to %NULL and @length is set to zero.
938 * Return value: %TRUE on success, %FALSE if an error occurred
941 g_file_get_contents (const gchar *filename,
946 g_return_val_if_fail (filename != NULL, FALSE);
947 g_return_val_if_fail (contents != NULL, FALSE);
954 return get_contents_win32 (filename, contents, length, error);
956 return get_contents_posix (filename, contents, length, error);
961 rename_file (const char *old_name,
962 const char *new_name,
966 if (g_rename (old_name, new_name) == -1)
968 int save_errno = errno;
969 gchar *display_old_name = g_filename_display_name (old_name);
970 gchar *display_new_name = g_filename_display_name (new_name);
974 g_file_error_from_errno (save_errno),
975 _("Failed to rename file '%s' to '%s': g_rename() failed: %s"),
978 g_strerror (save_errno));
980 g_free (display_old_name);
981 g_free (display_new_name);
990 format_error_message (const gchar *filename,
991 const gchar *format_string) G_GNUC_FORMAT(2);
993 #pragma GCC diagnostic push
994 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
997 format_error_message (const gchar *filename,
998 const gchar *format_string)
1000 gint saved_errno = errno;
1001 gchar *display_name;
1004 display_name = g_filename_display_name (filename);
1005 msg = g_strdup_printf (format_string, display_name, g_strerror (saved_errno));
1006 g_free (display_name);
1011 #pragma GCC diagnostic pop
1013 /* format string must have two '%s':
1015 * - the place for the filename
1016 * - the place for the strerror
1019 set_file_error (GError **error,
1020 const gchar *filename,
1021 const gchar *format_string)
1024 int saved_errno = errno;
1025 char *msg = format_error_message (filename, format_string);
1027 g_set_error_literal (error, G_FILE_ERROR, g_file_error_from_errno (saved_errno),
1033 write_to_temp_file (const gchar *contents,
1035 const gchar *dest_file,
1044 tmp_name = g_strdup_printf ("%s.XXXXXX", dest_file);
1047 fd = g_mkstemp_full (tmp_name, O_RDWR | O_BINARY, 0666);
1051 set_file_error (err, tmp_name, _("Failed to create file '%s': %s"));
1055 #ifdef HAVE_FALLOCATE
1058 /* We do this on a 'best effort' basis... It may not be supported
1059 * on the underlying filesystem.
1061 (void) fallocate (fd, 0, 0, length);
1068 s = write (fd, contents, length);
1075 set_file_error (err, tmp_name, _("Failed to write file '%s': write() failed: %s"));
1077 g_unlink (tmp_name);
1082 g_assert (s <= length);
1088 #ifdef BTRFS_SUPER_MAGIC
1092 /* On Linux, on btrfs, skip the fsync since rename-over-existing is
1093 * guaranteed to be atomic and this is the only case in which we
1094 * would fsync() anyway.
1097 if (fstatfs (fd, &buf) == 0 && buf.f_type == BTRFS_SUPER_MAGIC)
1104 struct stat statbuf;
1107 /* If the final destination exists and is > 0 bytes, we want to sync the
1108 * newly written file to ensure the data is on disk when we rename over
1109 * the destination. Otherwise if we get a system crash we can lose both
1110 * the new and the old file on some filesystems. (I.E. those that don't
1111 * guarantee the data is written to the disk before the metadata.)
1113 if (g_lstat (dest_file, &statbuf) == 0 && statbuf.st_size > 0 && fsync (fd) != 0)
1115 set_file_error (err, tmp_name, _("Failed to write file '%s': fsync() failed: %s"));
1117 g_unlink (tmp_name);
1124 #ifdef BTRFS_SUPER_MAGIC
1129 if (!g_close (fd, err))
1131 g_unlink (tmp_name);
1136 retval = g_strdup (tmp_name);
1145 * g_file_set_contents:
1146 * @filename: (type filename): name of a file to write @contents to, in the GLib file name
1148 * @contents: (array length=length) (element-type guint8): string to write to the file
1149 * @length: length of @contents, or -1 if @contents is a nul-terminated string
1150 * @error: return location for a #GError, or %NULL
1152 * Writes all of @contents to a file named @filename, with good error checking.
1153 * If a file called @filename already exists it will be overwritten.
1155 * This write is atomic in the sense that it is first written to a temporary
1156 * file which is then renamed to the final name. Notes:
1159 * On Unix, if @filename already exists hard links to @filename will break.
1160 * Also since the file is recreated, existing permissions, access control
1161 * lists, metadata etc. may be lost. If @filename is a symbolic link,
1162 * the link itself will be replaced, not the linked file.
1165 * On Windows renaming a file will not remove an existing file with the
1166 * new name, so on Windows there is a race condition between the existing
1167 * file being removed and the temporary file being renamed.
1170 * On Windows there is no way to remove a file that is open to some
1171 * process, or mapped into memory. Thus, this function will fail if
1172 * @filename already exists and is open.
1176 * If the call was successful, it returns %TRUE. If the call was not successful,
1177 * it returns %FALSE and sets @error. The error domain is #G_FILE_ERROR.
1178 * Possible error codes are those in the #GFileError enumeration.
1180 * Note that the name for the temporary file is constructed by appending up
1181 * to 7 characters to @filename.
1183 * Return value: %TRUE on success, %FALSE if an error occurred
1188 g_file_set_contents (const gchar *filename,
1189 const gchar *contents,
1193 gchar *tmp_filename;
1195 GError *rename_error = NULL;
1197 g_return_val_if_fail (filename != NULL, FALSE);
1198 g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
1199 g_return_val_if_fail (contents != NULL || length == 0, FALSE);
1200 g_return_val_if_fail (length >= -1, FALSE);
1203 length = strlen (contents);
1205 tmp_filename = write_to_temp_file (contents, length, filename, error);
1213 if (!rename_file (tmp_filename, filename, &rename_error))
1217 g_unlink (tmp_filename);
1218 g_propagate_error (error, rename_error);
1222 #else /* G_OS_WIN32 */
1224 /* Renaming failed, but on Windows this may just mean
1225 * the file already exists. So if the target file
1226 * exists, try deleting it and do the rename again.
1228 if (!g_file_test (filename, G_FILE_TEST_EXISTS))
1230 g_unlink (tmp_filename);
1231 g_propagate_error (error, rename_error);
1236 g_error_free (rename_error);
1238 if (g_unlink (filename) == -1)
1240 gchar *display_filename = g_filename_display_name (filename);
1242 int save_errno = errno;
1246 g_file_error_from_errno (save_errno),
1247 _("Existing file '%s' could not be removed: g_unlink() failed: %s"),
1249 g_strerror (save_errno));
1251 g_free (display_filename);
1252 g_unlink (tmp_filename);
1257 if (!rename_file (tmp_filename, filename, error))
1259 g_unlink (tmp_filename);
1270 g_free (tmp_filename);
1275 * get_tmp_file based on the mkstemp implementation from the GNU C library.
1276 * Copyright (C) 1991,92,93,94,95,96,97,98,99 Free Software Foundation, Inc.
1278 typedef gint (*GTmpFileCallback) (const gchar *, gint, gint);
1281 get_tmp_file (gchar *tmpl,
1288 static const char letters[] =
1289 "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
1290 static const int NLETTERS = sizeof (letters) - 1;
1293 static int counter = 0;
1295 g_return_val_if_fail (tmpl != NULL, -1);
1297 /* find the last occurrence of "XXXXXX" */
1298 XXXXXX = g_strrstr (tmpl, "XXXXXX");
1300 if (!XXXXXX || strncmp (XXXXXX, "XXXXXX", 6))
1306 /* Get some more or less random data. */
1307 g_get_current_time (&tv);
1308 value = (tv.tv_usec ^ tv.tv_sec) + counter++;
1310 for (count = 0; count < 100; value += 7777, ++count)
1314 /* Fill in the random bits. */
1315 XXXXXX[0] = letters[v % NLETTERS];
1317 XXXXXX[1] = letters[v % NLETTERS];
1319 XXXXXX[2] = letters[v % NLETTERS];
1321 XXXXXX[3] = letters[v % NLETTERS];
1323 XXXXXX[4] = letters[v % NLETTERS];
1325 XXXXXX[5] = letters[v % NLETTERS];
1327 fd = f (tmpl, flags, mode);
1331 else if (errno != EEXIST)
1332 /* Any other error will apply also to other names we might
1333 * try, and there are 2^32 or so of them, so give up now.
1338 /* We got out of the loop because we ran out of combinations to try. */
1343 /* Some GTmpFileCallback implementations.
1345 * Note: we cannot use open() or g_open() directly because even though
1346 * they appear compatible, they may be vararg functions and calling
1347 * varargs functions through a non-varargs type is undefined.
1350 wrap_g_mkdir (const gchar *filename,
1351 int flags G_GNUC_UNUSED,
1354 /* tmpl is in UTF-8 on Windows, thus use g_mkdir() */
1355 return g_mkdir (filename, mode);
1359 wrap_g_open (const gchar *filename,
1363 return g_open (filename, flags, mode);
1368 * @tmpl: (type filename): template directory name
1369 * @mode: permissions to create the temporary directory with
1371 * Creates a temporary directory. See the mkdtemp() documentation
1372 * on most UNIX-like systems.
1374 * The parameter is a string that should follow the rules for
1375 * mkdtemp() templates, i.e. contain the string "XXXXXX".
1376 * g_mkdtemp() is slightly more flexible than mkdtemp() in that the
1377 * sequence does not have to occur at the very end of the template
1378 * and you can pass a @mode. The X string will be modified to form
1379 * the name of a directory that didn't exist. The string should be
1380 * in the GLib file name encoding. Most importantly, on Windows it
1381 * should be in UTF-8.
1383 * Return value: A pointer to @tmpl, which has been modified
1384 * to hold the directory name. In case of errors, %NULL is
1385 * returned, and %errno will be set.
1390 g_mkdtemp_full (gchar *tmpl,
1393 if (get_tmp_file (tmpl, wrap_g_mkdir, 0, mode) == -1)
1401 * @tmpl: (type filename): template directory name
1403 * Creates a temporary directory. See the mkdtemp() documentation
1404 * on most UNIX-like systems.
1406 * The parameter is a string that should follow the rules for
1407 * mkdtemp() templates, i.e. contain the string "XXXXXX".
1408 * g_mkdtemp() is slightly more flexible than mkdtemp() in that the
1409 * sequence does not have to occur at the very end of the template
1410 * and you can pass a @mode and additional @flags. The X string will
1411 * be modified to form the name of a directory that didn't exist.
1412 * The string should be in the GLib file name encoding. Most importantly,
1413 * on Windows it should be in UTF-8.
1415 * Return value: A pointer to @tmpl, which has been modified
1416 * to hold the directory name. In case of errors, %NULL is
1417 * returned and %errno will be set.
1422 g_mkdtemp (gchar *tmpl)
1424 return g_mkdtemp_full (tmpl, 0700);
1429 * @tmpl: (type filename): template filename
1430 * @flags: flags to pass to an open() call in addition to O_EXCL
1431 * and O_CREAT, which are passed automatically
1432 * @mode: permissions to create the temporary file with
1434 * Opens a temporary file. See the mkstemp() documentation
1435 * on most UNIX-like systems.
1437 * The parameter is a string that should follow the rules for
1438 * mkstemp() templates, i.e. contain the string "XXXXXX".
1439 * g_mkstemp_full() is slightly more flexible than mkstemp()
1440 * in that the sequence does not have to occur at the very end of the
1441 * template and you can pass a @mode and additional @flags. The X
1442 * string will be modified to form the name of a file that didn't exist.
1443 * The string should be in the GLib file name encoding. Most importantly,
1444 * on Windows it should be in UTF-8.
1446 * Return value: A file handle (as from open()) to the file
1447 * opened for reading and writing. The file handle should be
1448 * closed with close(). In case of errors, -1 is returned
1449 * and %errno will be set.
1454 g_mkstemp_full (gchar *tmpl,
1458 /* tmpl is in UTF-8 on Windows, thus use g_open() */
1459 return get_tmp_file (tmpl, wrap_g_open,
1460 flags | O_CREAT | O_EXCL, mode);
1465 * @tmpl: (type filename): template filename
1467 * Opens a temporary file. See the mkstemp() documentation
1468 * on most UNIX-like systems.
1470 * The parameter is a string that should follow the rules for
1471 * mkstemp() templates, i.e. contain the string "XXXXXX".
1472 * g_mkstemp() is slightly more flexible than mkstemp() in that the
1473 * sequence does not have to occur at the very end of the template.
1474 * The X string will be modified to form the name of a file that
1475 * didn't exist. The string should be in the GLib file name encoding.
1476 * Most importantly, on Windows it should be in UTF-8.
1478 * Return value: A file handle (as from open()) to the file
1479 * opened for reading and writing. The file is opened in binary
1480 * mode on platforms where there is a difference. The file handle
1481 * should be closed with close(). In case of errors, -1 is
1482 * returned and %errno will be set.
1485 g_mkstemp (gchar *tmpl)
1487 return g_mkstemp_full (tmpl, O_RDWR | O_BINARY, 0600);
1491 g_get_tmp_name (const gchar *tmpl,
1507 if ((slash = strchr (tmpl, G_DIR_SEPARATOR)) != NULL
1509 || (strchr (tmpl, '/') != NULL && (slash = "/"))
1513 gchar *display_tmpl = g_filename_display_name (tmpl);
1520 G_FILE_ERROR_FAILED,
1521 _("Template '%s' invalid, should not contain a '%s'"),
1523 g_free (display_tmpl);
1528 if (strstr (tmpl, "XXXXXX") == NULL)
1530 gchar *display_tmpl = g_filename_display_name (tmpl);
1533 G_FILE_ERROR_FAILED,
1534 _("Template '%s' doesn't contain XXXXXX"),
1536 g_free (display_tmpl);
1540 tmpdir = g_get_tmp_dir ();
1542 if (G_IS_DIR_SEPARATOR (tmpdir [strlen (tmpdir) - 1]))
1545 sep = G_DIR_SEPARATOR_S;
1547 fulltemplate = g_strconcat (tmpdir, sep, tmpl, NULL);
1549 retval = get_tmp_file (fulltemplate, f, flags, mode);
1552 int save_errno = errno;
1553 gchar *display_fulltemplate = g_filename_display_name (fulltemplate);
1557 g_file_error_from_errno (save_errno),
1558 _("Failed to create file '%s': %s"),
1559 display_fulltemplate, g_strerror (save_errno));
1560 g_free (display_fulltemplate);
1561 g_free (fulltemplate);
1565 *name_used = fulltemplate;
1572 * @tmpl: (type filename) (allow-none): Template for file name, as in
1573 * g_mkstemp(), basename only, or %NULL for a default template
1574 * @name_used: (out) (type filename): location to store actual name used,
1576 * @error: return location for a #GError
1578 * Opens a file for writing in the preferred directory for temporary
1579 * files (as returned by g_get_tmp_dir()).
1581 * @tmpl should be a string in the GLib file name encoding containing
1582 * a sequence of six 'X' characters, as the parameter to g_mkstemp().
1583 * However, unlike these functions, the template should only be a
1584 * basename, no directory components are allowed. If template is
1585 * %NULL, a default template is used.
1587 * Note that in contrast to g_mkstemp() (and mkstemp()) @tmpl is not
1588 * modified, and might thus be a read-only literal string.
1590 * Upon success, and if @name_used is non-%NULL, the actual name used
1591 * is returned in @name_used. This string should be freed with g_free()
1592 * when not needed any longer. The returned name is in the GLib file
1595 * Return value: A file handle (as from open()) to the file opened for
1596 * reading and writing. The file is opened in binary mode on platforms
1597 * where there is a difference. The file handle should be closed with
1598 * close(). In case of errors, -1 is returned and @error will be set.
1601 g_file_open_tmp (const gchar *tmpl,
1605 gchar *fulltemplate;
1608 result = g_get_tmp_name (tmpl, &fulltemplate,
1610 O_CREAT | O_EXCL | O_RDWR | O_BINARY,
1616 *name_used = fulltemplate;
1618 g_free (fulltemplate);
1626 * @tmpl: (type filename) (allow-none): Template for directory name,
1627 * as in g_mkdtemp(), basename only, or %NULL for a default template
1628 * @error: return location for a #GError
1630 * Creates a subdirectory in the preferred directory for temporary
1631 * files (as returned by g_get_tmp_dir()).
1633 * @tmpl should be a string in the GLib file name encoding containing
1634 * a sequence of six 'X' characters, as the parameter to g_mkstemp().
1635 * However, unlike these functions, the template should only be a
1636 * basename, no directory components are allowed. If template is
1637 * %NULL, a default template is used.
1639 * Note that in contrast to g_mkdtemp() (and mkdtemp()) @tmpl is not
1640 * modified, and might thus be a read-only literal string.
1642 * Return value: (type filename): The actual name used. This string
1643 * should be freed with g_free() when not needed any longer and is
1644 * is in the GLib file name encoding. In case of errors, %NULL is
1645 * returned and @error will be set.
1650 g_dir_make_tmp (const gchar *tmpl,
1653 gchar *fulltemplate;
1655 if (g_get_tmp_name (tmpl, &fulltemplate, wrap_g_mkdir, 0, 0700, error) == -1)
1658 return fulltemplate;
1662 g_build_path_va (const gchar *separator,
1663 const gchar *first_element,
1668 gint separator_len = strlen (separator);
1669 gboolean is_first = TRUE;
1670 gboolean have_leading = FALSE;
1671 const gchar *single_element = NULL;
1672 const gchar *next_element;
1673 const gchar *last_trailing = NULL;
1676 result = g_string_new (NULL);
1679 next_element = str_array[i++];
1681 next_element = first_element;
1685 const gchar *element;
1691 element = next_element;
1693 next_element = str_array[i++];
1695 next_element = va_arg (*args, gchar *);
1700 /* Ignore empty elements */
1708 while (strncmp (start, separator, separator_len) == 0)
1709 start += separator_len;
1712 end = start + strlen (start);
1716 while (end >= start + separator_len &&
1717 strncmp (end - separator_len, separator, separator_len) == 0)
1718 end -= separator_len;
1720 last_trailing = end;
1721 while (last_trailing >= element + separator_len &&
1722 strncmp (last_trailing - separator_len, separator, separator_len) == 0)
1723 last_trailing -= separator_len;
1727 /* If the leading and trailing separator strings are in the
1728 * same element and overlap, the result is exactly that element
1730 if (last_trailing <= start)
1731 single_element = element;
1733 g_string_append_len (result, element, start - element);
1734 have_leading = TRUE;
1737 single_element = NULL;
1744 g_string_append (result, separator);
1746 g_string_append_len (result, start, end - start);
1752 g_string_free (result, TRUE);
1753 return g_strdup (single_element);
1758 g_string_append (result, last_trailing);
1760 return g_string_free (result, FALSE);
1766 * @separator: a string used to separator the elements of the path.
1767 * @args: (array zero-terminated=1): %NULL-terminated array of strings containing the path elements.
1769 * Behaves exactly like g_build_path(), but takes the path elements
1770 * as a string array, instead of varargs. This function is mainly
1771 * meant for language bindings.
1773 * Return value: a newly-allocated string that must be freed with g_free().
1778 g_build_pathv (const gchar *separator,
1784 return g_build_path_va (separator, NULL, NULL, args);
1790 * @separator: a string used to separator the elements of the path.
1791 * @first_element: the first element in the path
1792 * @...: remaining elements in path, terminated by %NULL
1794 * Creates a path from a series of elements using @separator as the
1795 * separator between elements. At the boundary between two elements,
1796 * any trailing occurrences of separator in the first element, or
1797 * leading occurrences of separator in the second element are removed
1798 * and exactly one copy of the separator is inserted.
1800 * Empty elements are ignored.
1802 * The number of leading copies of the separator on the result is
1803 * the same as the number of leading copies of the separator on
1804 * the first non-empty element.
1806 * The number of trailing copies of the separator on the result is
1807 * the same as the number of trailing copies of the separator on
1808 * the last non-empty element. (Determination of the number of
1809 * trailing copies is done without stripping leading copies, so
1810 * if the separator is <literal>ABA</literal>, <literal>ABABA</literal>
1811 * has 1 trailing copy.)
1813 * However, if there is only a single non-empty element, and there
1814 * are no characters in that element not part of the leading or
1815 * trailing separators, then the result is exactly the original value
1818 * Other than for determination of the number of leading and trailing
1819 * copies of the separator, elements consisting only of copies
1820 * of the separator are ignored.
1822 * Return value: a newly-allocated string that must be freed with g_free().
1825 g_build_path (const gchar *separator,
1826 const gchar *first_element,
1832 g_return_val_if_fail (separator != NULL, NULL);
1834 va_start (args, first_element);
1835 str = g_build_path_va (separator, first_element, &args, NULL);
1844 g_build_pathname_va (const gchar *first_element,
1848 /* Code copied from g_build_pathv(), and modified to use two
1849 * alternative single-character separators.
1852 gboolean is_first = TRUE;
1853 gboolean have_leading = FALSE;
1854 const gchar *single_element = NULL;
1855 const gchar *next_element;
1856 const gchar *last_trailing = NULL;
1857 gchar current_separator = '\\';
1860 result = g_string_new (NULL);
1863 next_element = str_array[i++];
1865 next_element = first_element;
1869 const gchar *element;
1875 element = next_element;
1877 next_element = str_array[i++];
1879 next_element = va_arg (*args, gchar *);
1884 /* Ignore empty elements */
1893 (*start == '\\' || *start == '/'))
1895 current_separator = *start;
1900 end = start + strlen (start);
1904 while (end >= start + 1 &&
1905 (end[-1] == '\\' || end[-1] == '/'))
1907 current_separator = end[-1];
1911 last_trailing = end;
1912 while (last_trailing >= element + 1 &&
1913 (last_trailing[-1] == '\\' || last_trailing[-1] == '/'))
1918 /* If the leading and trailing separator strings are in the
1919 * same element and overlap, the result is exactly that element
1921 if (last_trailing <= start)
1922 single_element = element;
1924 g_string_append_len (result, element, start - element);
1925 have_leading = TRUE;
1928 single_element = NULL;
1935 g_string_append_len (result, ¤t_separator, 1);
1937 g_string_append_len (result, start, end - start);
1943 g_string_free (result, TRUE);
1944 return g_strdup (single_element);
1949 g_string_append (result, last_trailing);
1951 return g_string_free (result, FALSE);
1958 * g_build_filenamev:
1959 * @args: (array zero-terminated=1): %NULL-terminated array of strings containing the path elements.
1961 * Behaves exactly like g_build_filename(), but takes the path elements
1962 * as a string array, instead of varargs. This function is mainly
1963 * meant for language bindings.
1965 * Return value: a newly-allocated string that must be freed with g_free().
1970 g_build_filenamev (gchar **args)
1975 str = g_build_path_va (G_DIR_SEPARATOR_S, NULL, NULL, args);
1977 str = g_build_pathname_va (NULL, NULL, args);
1985 * @first_element: the first element in the path
1986 * @...: remaining elements in path, terminated by %NULL
1988 * Creates a filename from a series of elements using the correct
1989 * separator for filenames.
1991 * On Unix, this function behaves identically to <literal>g_build_path
1992 * (G_DIR_SEPARATOR_S, first_element, ....)</literal>.
1994 * On Windows, it takes into account that either the backslash
1995 * (<literal>\</literal> or slash (<literal>/</literal>) can be used
1996 * as separator in filenames, but otherwise behaves as on Unix. When
1997 * file pathname separators need to be inserted, the one that last
1998 * previously occurred in the parameters (reading from left to right)
2001 * No attempt is made to force the resulting filename to be an absolute
2002 * path. If the first element is a relative path, the result will
2003 * be a relative path.
2005 * Return value: a newly-allocated string that must be freed with g_free().
2008 g_build_filename (const gchar *first_element,
2014 va_start (args, first_element);
2016 str = g_build_path_va (G_DIR_SEPARATOR_S, first_element, &args, NULL);
2018 str = g_build_pathname_va (first_element, &args, NULL);
2027 * @filename: the symbolic link
2028 * @error: return location for a #GError
2030 * Reads the contents of the symbolic link @filename like the POSIX
2031 * readlink() function. The returned string is in the encoding used
2032 * for filenames. Use g_filename_to_utf8() to convert it to UTF-8.
2034 * Returns: A newly-allocated string with the contents of the symbolic link,
2035 * or %NULL if an error occurred.
2040 g_file_read_link (const gchar *filename,
2043 #ifdef HAVE_READLINK
2049 buffer = g_malloc (size);
2053 read_size = readlink (filename, buffer, size);
2054 if (read_size < 0) {
2055 int save_errno = errno;
2056 gchar *display_filename = g_filename_display_name (filename);
2061 g_file_error_from_errno (save_errno),
2062 _("Failed to read the symbolic link '%s': %s"),
2064 g_strerror (save_errno));
2065 g_free (display_filename);
2070 if (read_size < size)
2072 buffer[read_size] = 0;
2077 buffer = g_realloc (buffer, size);
2080 g_set_error_literal (error,
2083 _("Symbolic links not supported"));
2090 * g_path_is_absolute:
2091 * @file_name: a file name
2093 * Returns %TRUE if the given @file_name is an absolute file name.
2094 * Note that this is a somewhat vague concept on Windows.
2096 * On POSIX systems, an absolute file name is well-defined. It always
2097 * starts from the single root directory. For example "/usr/local".
2099 * On Windows, the concepts of current drive and drive-specific
2100 * current directory introduce vagueness. This function interprets as
2101 * an absolute file name one that either begins with a directory
2102 * separator such as "\Users\tml" or begins with the root on a drive,
2103 * for example "C:\Windows". The first case also includes UNC paths
2104 * such as "\\myserver\docs\foo". In all cases, either slashes or
2105 * backslashes are accepted.
2107 * Note that a file name relative to the current drive root does not
2108 * truly specify a file uniquely over time and across processes, as
2109 * the current drive is a per-process value and can be changed.
2111 * File names relative the current directory on some specific drive,
2112 * such as "D:foo/bar", are not interpreted as absolute by this
2113 * function, but they obviously are not relative to the normal current
2114 * directory as returned by getcwd() or g_get_current_dir()
2115 * either. Such paths should be avoided, or need to be handled using
2116 * Windows-specific code.
2118 * Returns: %TRUE if @file_name is absolute
2121 g_path_is_absolute (const gchar *file_name)
2123 g_return_val_if_fail (file_name != NULL, FALSE);
2125 if (G_IS_DIR_SEPARATOR (file_name[0]))
2129 /* Recognize drive letter on native Windows */
2130 if (g_ascii_isalpha (file_name[0]) &&
2131 file_name[1] == ':' && G_IS_DIR_SEPARATOR (file_name[2]))
2140 * @file_name: a file name
2142 * Returns a pointer into @file_name after the root component,
2143 * i.e. after the "/" in UNIX or "C:\" under Windows. If @file_name
2144 * is not an absolute path it returns %NULL.
2146 * Returns: a pointer into @file_name after the root component
2149 g_path_skip_root (const gchar *file_name)
2151 g_return_val_if_fail (file_name != NULL, NULL);
2153 #ifdef G_PLATFORM_WIN32
2154 /* Skip \\server\share or //server/share */
2155 if (G_IS_DIR_SEPARATOR (file_name[0]) &&
2156 G_IS_DIR_SEPARATOR (file_name[1]) &&
2158 !G_IS_DIR_SEPARATOR (file_name[2]))
2161 p = strchr (file_name + 2, G_DIR_SEPARATOR);
2167 q = strchr (file_name + 2, '/');
2168 if (p == NULL || (q != NULL && q < p))
2173 if (p && p > file_name + 2 && p[1])
2177 while (file_name[0] && !G_IS_DIR_SEPARATOR (file_name[0]))
2180 /* Possibly skip a backslash after the share name */
2181 if (G_IS_DIR_SEPARATOR (file_name[0]))
2184 return (gchar *)file_name;
2189 /* Skip initial slashes */
2190 if (G_IS_DIR_SEPARATOR (file_name[0]))
2192 while (G_IS_DIR_SEPARATOR (file_name[0]))
2194 return (gchar *)file_name;
2199 if (g_ascii_isalpha (file_name[0]) &&
2200 file_name[1] == ':' &&
2201 G_IS_DIR_SEPARATOR (file_name[2]))
2202 return (gchar *)file_name + 3;
2210 * @file_name: the name of the file
2212 * Gets the name of the file without any leading directory
2213 * components. It returns a pointer into the given file name
2216 * Return value: the name of the file without any leading
2217 * directory components
2219 * Deprecated:2.2: Use g_path_get_basename() instead, but notice
2220 * that g_path_get_basename() allocates new memory for the
2221 * returned string, unlike this function which returns a pointer
2222 * into the argument.
2225 g_basename (const gchar *file_name)
2229 g_return_val_if_fail (file_name != NULL, NULL);
2231 base = strrchr (file_name, G_DIR_SEPARATOR);
2236 q = strrchr (file_name, '/');
2237 if (base == NULL || (q != NULL && q > base))
2246 if (g_ascii_isalpha (file_name[0]) && file_name[1] == ':')
2247 return (gchar*) file_name + 2;
2250 return (gchar*) file_name;
2254 * g_path_get_basename:
2255 * @file_name: the name of the file
2257 * Gets the last component of the filename.
2259 * If @file_name ends with a directory separator it gets the component
2260 * before the last slash. If @file_name consists only of directory
2261 * separators (and on Windows, possibly a drive letter), a single
2262 * separator is returned. If @file_name is empty, it gets ".".
2264 * Return value: a newly allocated string containing the last
2265 * component of the filename
2268 g_path_get_basename (const gchar *file_name)
2271 gssize last_nonslash;
2275 g_return_val_if_fail (file_name != NULL, NULL);
2277 if (file_name[0] == '\0')
2278 return g_strdup (".");
2280 last_nonslash = strlen (file_name) - 1;
2282 while (last_nonslash >= 0 && G_IS_DIR_SEPARATOR (file_name [last_nonslash]))
2285 if (last_nonslash == -1)
2286 /* string only containing slashes */
2287 return g_strdup (G_DIR_SEPARATOR_S);
2290 if (last_nonslash == 1 &&
2291 g_ascii_isalpha (file_name[0]) &&
2292 file_name[1] == ':')
2293 /* string only containing slashes and a drive */
2294 return g_strdup (G_DIR_SEPARATOR_S);
2296 base = last_nonslash;
2298 while (base >=0 && !G_IS_DIR_SEPARATOR (file_name [base]))
2303 g_ascii_isalpha (file_name[0]) &&
2304 file_name[1] == ':')
2306 #endif /* G_OS_WIN32 */
2308 len = last_nonslash - base;
2309 retval = g_malloc (len + 1);
2310 memcpy (retval, file_name + base + 1, len);
2311 retval [len] = '\0';
2318 * @file_name: the name of the file
2320 * Gets the directory components of a file name.
2322 * If the file name has no directory components "." is returned.
2323 * The returned string should be freed when no longer needed.
2325 * Returns: the directory components of the file
2327 * Deprecated: use g_path_get_dirname() instead
2331 * g_path_get_dirname:
2332 * @file_name: the name of the file
2334 * Gets the directory components of a file name.
2336 * If the file name has no directory components "." is returned.
2337 * The returned string should be freed when no longer needed.
2339 * Returns: the directory components of the file
2342 g_path_get_dirname (const gchar *file_name)
2347 g_return_val_if_fail (file_name != NULL, NULL);
2349 base = strrchr (file_name, G_DIR_SEPARATOR);
2354 q = strrchr (file_name, '/');
2355 if (base == NULL || (q != NULL && q > base))
2363 if (g_ascii_isalpha (file_name[0]) && file_name[1] == ':')
2365 gchar drive_colon_dot[4];
2367 drive_colon_dot[0] = file_name[0];
2368 drive_colon_dot[1] = ':';
2369 drive_colon_dot[2] = '.';
2370 drive_colon_dot[3] = '\0';
2372 return g_strdup (drive_colon_dot);
2375 return g_strdup (".");
2378 while (base > file_name && G_IS_DIR_SEPARATOR (*base))
2382 /* base points to the char before the last slash.
2384 * In case file_name is the root of a drive (X:\) or a child of the
2385 * root of a drive (X:\foo), include the slash.
2387 * In case file_name is the root share of an UNC path
2388 * (\\server\share), add a slash, returning \\server\share\ .
2390 * In case file_name is a direct child of a share in an UNC path
2391 * (\\server\share\foo), include the slash after the share name,
2392 * returning \\server\share\ .
2394 if (base == file_name + 1 &&
2395 g_ascii_isalpha (file_name[0]) &&
2396 file_name[1] == ':')
2398 else if (G_IS_DIR_SEPARATOR (file_name[0]) &&
2399 G_IS_DIR_SEPARATOR (file_name[1]) &&
2401 !G_IS_DIR_SEPARATOR (file_name[2]) &&
2402 base >= file_name + 2)
2404 const gchar *p = file_name + 2;
2405 while (*p && !G_IS_DIR_SEPARATOR (*p))
2409 len = (guint) strlen (file_name) + 1;
2410 base = g_new (gchar, len + 1);
2411 strcpy (base, file_name);
2412 base[len-1] = G_DIR_SEPARATOR;
2416 if (G_IS_DIR_SEPARATOR (*p))
2419 while (*p && !G_IS_DIR_SEPARATOR (*p))
2427 len = (guint) 1 + base - file_name;
2428 base = g_new (gchar, len + 1);
2429 memmove (base, file_name, len);
2435 #if defined(MAXPATHLEN)
2436 #define G_PATH_LENGTH MAXPATHLEN
2437 #elif defined(PATH_MAX)
2438 #define G_PATH_LENGTH PATH_MAX
2439 #elif defined(_PC_PATH_MAX)
2440 #define G_PATH_LENGTH sysconf(_PC_PATH_MAX)
2442 #define G_PATH_LENGTH 2048
2446 * g_get_current_dir:
2448 * Gets the current directory.
2450 * The returned string should be freed when no longer needed.
2451 * The encoding of the returned string is system defined.
2452 * On Windows, it is always UTF-8.
2454 * Since GLib 2.40, this function will return the value of the "PWD"
2455 * environment variable if it is set and it happens to be the same as
2456 * the current directory. This can make a difference in the case that
2457 * the current directory is the target of a symbolic link.
2459 * Returns: the current directory
2462 g_get_current_dir (void)
2467 wchar_t dummy[2], *wdir;
2470 len = GetCurrentDirectoryW (2, dummy);
2471 wdir = g_new (wchar_t, len);
2473 if (GetCurrentDirectoryW (len, wdir) == len - 1)
2474 dir = g_utf16_to_utf8 (wdir, -1, NULL, NULL, NULL);
2479 dir = g_strdup ("\\");
2485 gchar *buffer = NULL;
2487 static gulong max_len = 0;
2488 struct stat pwdbuf, dotbuf;
2490 pwd = g_getenv ("PWD");
2492 g_stat (".", &dotbuf) == 0 && g_stat (pwd, &pwdbuf) == 0 &&
2493 dotbuf.st_dev == pwdbuf.st_dev && dotbuf.st_ino == pwdbuf.st_ino)
2494 return g_strdup (pwd);
2497 max_len = (G_PATH_LENGTH == -1) ? 2048 : G_PATH_LENGTH;
2499 while (max_len < G_MAXULONG / 2)
2502 buffer = g_new (gchar, max_len + 1);
2504 dir = getcwd (buffer, max_len);
2506 if (dir || errno != ERANGE)
2512 if (!dir || !*buffer)
2514 /* hm, should we g_error() out here?
2515 * this can happen if e.g. "./" has mode \0000
2517 buffer[0] = G_DIR_SEPARATOR;
2521 dir = g_strdup (buffer);
2526 #endif /* !G_OS_WIN32 */
2530 /* NOTE : Keep this part last to ensure nothing in this file uses thn
2531 * below binary compatibility versions.
2533 #if defined (G_OS_WIN32) && !defined (_WIN64)
2535 /* Binary compatibility versions. Will be called by code compiled
2536 * against quite old (pre-2.8, I think) headers only, not from more
2537 * recently compiled code.
2543 g_file_test (const gchar *filename,
2546 gchar *utf8_filename = g_locale_to_utf8 (filename, -1, NULL, NULL, NULL);
2549 if (utf8_filename == NULL)
2552 retval = g_file_test_utf8 (utf8_filename, test);
2554 g_free (utf8_filename);
2559 #undef g_file_get_contents
2562 g_file_get_contents (const gchar *filename,
2567 gchar *utf8_filename = g_locale_to_utf8 (filename, -1, NULL, NULL, error);
2570 if (utf8_filename == NULL)
2573 retval = g_file_get_contents_utf8 (utf8_filename, contents, length, error);
2575 g_free (utf8_filename);
2583 wrap_libc_open (const gchar *filename,
2587 return open (filename, flags, mode);
2591 g_mkstemp (gchar *tmpl)
2593 /* This is the backward compatibility system codepage version,
2594 * thus use normal open().
2596 return get_tmp_file (tmpl, wrap_libc_open,
2597 O_RDWR | O_CREAT | O_EXCL, 0600);
2600 #undef g_file_open_tmp
2603 g_file_open_tmp (const gchar *tmpl,
2607 gchar *utf8_tmpl = g_locale_to_utf8 (tmpl, -1, NULL, NULL, error);
2608 gchar *utf8_name_used;
2611 if (utf8_tmpl == NULL)
2614 retval = g_file_open_tmp_utf8 (utf8_tmpl, &utf8_name_used, error);
2620 *name_used = g_locale_from_utf8 (utf8_name_used, -1, NULL, NULL, NULL);
2622 g_free (utf8_name_used);
2627 #undef g_get_current_dir
2630 g_get_current_dir (void)
2632 gchar *utf8_dir = g_get_current_dir_utf8 ();
2633 gchar *dir = g_locale_from_utf8 (utf8_dir, -1, NULL, NULL, NULL);